QGIS API Documentation 3.41.0-Master (3440c17df1d)
Loading...
Searching...
No Matches
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
18#include "moc_qgslayoutitemscalebar.cpp"
21#include "qgslayoutitemmap.h"
22#include "qgslayout.h"
23#include "qgslayoututils.h"
24#include "qgsdistancearea.h"
26#include "qgsscalebarrenderer.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"
42
43#include <QDomDocument>
44#include <QDomElement>
45#include <QFontMetricsF>
46#include <QPainter>
47#include <QTextDocument>
48#include <QAbstractTextDocumentLayout>
49
50#include <cmath>
51
58
63
65{
66 return QgsApplication::getThemeIcon( QStringLiteral( "/mLayoutItemScaleBar.svg" ) );
67}
68
73
75{
77
78 const QgsScaleBarRenderer::ScaleBarContext scaleContext = createScaleContext();
79 if ( !scaleContext.isValid() )
80 return QgsLayoutSize();
81
82 return QgsLayoutSize( mStyle->calculateBoxSize( context, mSettings, scaleContext ), Qgis::LayoutUnit::Millimeters );
83}
84
86{
87 if ( !mStyle )
88 return;
89
90 const QgsScaleBarRenderer::ScaleBarContext scaleContext = createScaleContext();
91 if ( !scaleContext.isValid() )
92 {
93 if ( mLayout->renderContext().isPreviewRender() )
94 {
95 // No initial render available - so draw some preview text alerting user
96 QPainter *painter = context.renderContext().painter();
97
98 const double scale = context.renderContext().convertToPainterUnits( 1, Qgis::RenderUnit::Millimeters );
99 const QRectF thisPaintRect = QRectF( 0, 0, rect().width() * scale, rect().height() * scale );
100
101 painter->setBrush( QBrush( QColor( 255, 125, 125, 125 ) ) );
102 painter->setPen( Qt::NoPen );
103 painter->drawRect( thisPaintRect );
104 painter->setBrush( Qt::NoBrush );
105
106 painter->setPen( QColor( 200, 0, 0, 255 ) );
107 QTextDocument td;
108 td.setTextWidth( thisPaintRect.width() );
109 td.setHtml( QStringLiteral( "<span style=\"color: rgb(200,0,0);\"><b>%1</b><br>%2</span>" ).arg(
110 tr( "Invalid scale!" ),
111 tr( "The scale bar cannot be rendered due to invalid settings or an incompatible linked map extent." ) ) );
112 painter->setClipRect( thisPaintRect );
113 QAbstractTextDocumentLayout::PaintContext ctx;
114 td.documentLayout()->draw( painter, ctx );
115 }
116 return;
117 }
118
120 {
121 // compatibility code - ScalebarLineColor and ScalebarLineWidth are deprecated
123 std::unique_ptr< QgsLineSymbol > sym( mSettings.lineSymbol()->clone() );
130 mSettings.setLineSymbol( sym.release() );
131 }
133 {
134 // compatibility code - ScalebarLineColor and ScalebarLineWidth are deprecated
136 std::unique_ptr< QgsFillSymbol > sym( mSettings.fillSymbol()->clone() );
140 mSettings.setFillSymbol( sym.release() );
141 }
143 {
144 // compatibility code - ScalebarLineColor and ScalebarLineWidth are deprecated
146 std::unique_ptr< QgsFillSymbol > sym( mSettings.alternateFillSymbol()->clone() );
150 mSettings.setAlternateFillSymbol( sym.release() );
151 }
152
153 mStyle->draw( context.renderContext(), mSettings, scaleContext );
154}
155
157{
158 if ( !mStyle )
159 {
160 mSettings.setNumberOfSegments( nSegments );
161 return;
162 }
163 mSettings.setNumberOfSegments( nSegments );
165}
166
168{
169 if ( !mStyle )
170 {
171 mSettings.setUnitsPerSegment( units );
172 return;
173 }
174 mSettings.setUnitsPerSegment( units );
175 refreshSegmentMillimeters();
177}
178
179
181{
182 if ( !mStyle )
183 {
184 mSettings.setSegmentSizeMode( mode );
185 return;
186 }
187 mSettings.setSegmentSizeMode( mode );
188 refreshSegmentMillimeters();
190}
191
193{
194 if ( !mStyle )
195 {
196 mSettings.setMinimumBarWidth( minWidth );
197 return;
198 }
199 mSettings.setMinimumBarWidth( minWidth );
200 refreshSegmentMillimeters();
202}
203
205{
206 if ( !mStyle )
207 {
208 mSettings.setMaximumBarWidth( maxWidth );
209 return;
210 }
211 mSettings.setMaximumBarWidth( maxWidth );
212 refreshSegmentMillimeters();
214}
215
217{
218 return mSettings.textFormat();
219}
220
222{
223 mSettings.setTextFormat( format );
225 emit changed();
226}
227
229{
230 return mSettings.lineSymbol();
231}
232
234{
235 mSettings.setLineSymbol( symbol );
236}
237
242
247
252
257
259{
260 return mSettings.fillSymbol();
261}
262
264{
265 mSettings.setFillSymbol( symbol );
266}
267
272
277
279{
280 if ( !mStyle )
281 {
282 mSettings.setNumberOfSegmentsLeft( nSegmentsLeft );
283 return;
284 }
285 mSettings.setNumberOfSegmentsLeft( nSegmentsLeft );
287}
288
290{
291 if ( !mStyle )
292 {
293 mSettings.setBoxContentSpace( space );
294 return;
295 }
296 mSettings.setBoxContentSpace( space );
298}
299
301{
302 disconnectCurrentMap();
303
304 mMap = map;
305
306 if ( !map )
307 {
308 return;
309 }
310
311 connect( mMap, &QgsLayoutItemMap::extentChanged, this, &QgsLayoutItemScaleBar::updateScale );
312 connect( mMap, &QObject::destroyed, this, &QgsLayoutItemScaleBar::disconnectCurrentMap );
313
314 refreshSegmentMillimeters();
315 emit changed();
316}
317
318void QgsLayoutItemScaleBar::disconnectCurrentMap()
319{
320 if ( !mMap )
321 {
322 return;
323 }
324
325 disconnect( mMap, &QgsLayoutItemMap::extentChanged, this, &QgsLayoutItemScaleBar::updateScale );
326 disconnect( mMap, &QObject::destroyed, this, &QgsLayoutItemScaleBar::disconnectCurrentMap );
327 mMap = nullptr;
328}
329
334
336{
337 if ( mMethod == method )
338 return;
339
340 mMethod = method;
341 refreshSegmentMillimeters();
343}
344
345void QgsLayoutItemScaleBar::refreshUnitsPerSegment( const QgsExpressionContext *context )
346{
348 {
349 double unitsPerSegment = mSettings.unitsPerSegment();
350 bool ok = false;
352
353 if ( !ok )
354 {
355 QgsMessageLog::logMessage( tr( "Scalebar units per segment expression eval error" ) );
356 }
357 else
358 {
360 }
361 }
362}
363
364void QgsLayoutItemScaleBar::refreshMinimumBarWidth( const QgsExpressionContext *context )
365{
367 {
368 double minimumBarWidth = mSettings.minimumBarWidth();
369
370 bool ok = false;
372
373 if ( !ok )
374 {
375 QgsMessageLog::logMessage( tr( "Scalebar minimum segment width expression eval error" ) );
376 }
377 else
378 {
380 }
381 }
382}
383
384void QgsLayoutItemScaleBar::refreshMaximumBarWidth( const QgsExpressionContext *context )
385{
387 {
388 double maximumBarWidth = mSettings.maximumBarWidth();
389
390 bool ok = false;
392
393 if ( !ok )
394 {
395 QgsMessageLog::logMessage( tr( "Scalebar maximum segment width expression eval error" ) );
396 }
397 else
398 {
400 }
401 }
402}
403
404void QgsLayoutItemScaleBar::refreshNumberOfSegmentsLeft( const QgsExpressionContext *context )
405{
407 {
408 int leftSegments = mSettings.numberOfSegmentsLeft();
409
410 bool ok = false;
412
413 if ( !ok )
414 {
415 QgsMessageLog::logMessage( tr( "Scalebar left segment count expression eval error" ) );
416 }
417 else
418 {
419 setNumberOfSegmentsLeft( leftSegments );
420 }
421 }
422}
423
424void QgsLayoutItemScaleBar::refreshNumberOfSegmentsRight( const QgsExpressionContext *context )
425{
427 {
428 int rightSegments = mSettings.numberOfSegments();
429
430 bool ok = false;
432
433 if ( !ok )
434 {
435 QgsMessageLog::logMessage( tr( "Scalebar left segment count expression eval error" ) );
436 }
437 else
438 {
439 setNumberOfSegments( rightSegments );
440 }
441 }
442}
443
445{
447
448 bool forceUpdate = false;
449
452 {
453 double height = mSettings.height();
454
455 bool ok = false;
457
458 if ( !ok )
459 {
460 QgsMessageLog::logMessage( tr( "Scalebar height expression eval error" ) );
461 }
462 else
463 {
464 setHeight( height );
465 }
466
467 forceUpdate = true;
468 }
469
472 {
473 double height = mSettings.subdivisionsHeight();
474
475 bool ok = false;
477
478 if ( !ok )
479 {
480 QgsMessageLog::logMessage( tr( "Scalebar subdivision height expression eval error" ) );
481 }
482 else
483 {
485 }
486
487 forceUpdate = true;
488 }
489
491 {
492 refreshNumberOfSegmentsLeft( &context );
493 forceUpdate = true;
494 }
495
497 {
498 refreshNumberOfSegmentsRight( &context );
499 forceUpdate = true;
500 }
501
504 {
505 int segments = mSettings.numberOfSubdivisions();
506
507 bool ok = false;
509
510 if ( !ok )
511 {
512 QgsMessageLog::logMessage( tr( "Scalebar number of subdivisions expression eval error" ) );
513 }
514 else
515 {
516 setNumberOfSubdivisions( segments );
517 }
518
519 forceUpdate = true;
520 }
521
522
524 {
525 refreshUnitsPerSegment( &context );
526 forceUpdate = true;
527 }
528
530 {
531 refreshMinimumBarWidth( &context );
532 forceUpdate = true;
533 }
534
536 {
537 refreshMaximumBarWidth( &context );
538 forceUpdate = true;
539 }
540
541 // updates data defined properties and redraws item to match
542 // -- Deprecated --
544 {
545 forceUpdate = true;
546 }
548 {
549 forceUpdate = true;
550 }
552 {
553 forceUpdate = true;
554 }
556 {
557 forceUpdate = true;
558 }
559
560 if ( forceUpdate )
561 {
563 update();
564 }
565
567}
568
569void QgsLayoutItemScaleBar::refreshSegmentMillimeters()
570{
571 if ( mMap )
572 {
573 //get mm dimension of composer map
574 const QRectF composerItemRect = mMap->rect();
575
576 const double currentMapWidth = mapWidth();
577 if ( qgsDoubleNear( currentMapWidth, 0 ) || std::isnan( currentMapWidth ) )
578 {
579 mSegmentMillimeters = std::numeric_limits< double >::quiet_NaN();
580 return;
581 }
582
583 switch ( mSettings.segmentSizeMode() )
584 {
586 {
587 //calculate size depending on mNumUnitsPerSegment
588 mSegmentMillimeters = composerItemRect.width() / currentMapWidth * mSettings.unitsPerSegment();
589 break;
590 }
591
593 {
594 if ( mSettings.maximumBarWidth() < mSettings.minimumBarWidth() )
595 {
596 mSegmentMillimeters = 0;
597 }
598 else
599 {
600 const double nSegments = ( mSettings.numberOfSegmentsLeft() != 0 ) + mSettings.numberOfSegments();
601 // unitsPerSegments which fit minBarWidth resp. maxBarWidth
602 const double minUnitsPerSeg = ( mSettings.minimumBarWidth() * currentMapWidth ) / ( nSegments * composerItemRect.width() );
603 const double maxUnitsPerSeg = ( mSettings.maximumBarWidth() * currentMapWidth ) / ( nSegments * composerItemRect.width() );
604 mSettings.setUnitsPerSegment( QgsLayoutUtils::calculatePrettySize( minUnitsPerSeg, maxUnitsPerSeg ) );
605 mSegmentMillimeters = composerItemRect.width() / currentMapWidth * mSettings.unitsPerSegment();
606 }
607 break;
608 }
609 }
610 }
611}
612
613double QgsLayoutItemScaleBar::mapWidth() const
614{
615 if ( !mMap )
616 {
617 return 0.0;
618 }
619
620 const QgsRectangle mapExtent = mMap->extent();
621 if ( mSettings.units() == Qgis::DistanceUnit::Unknown )
622 {
623 return mapExtent.width();
624 }
625 else
626 {
628 da.setSourceCrs( mMap->crs(), mLayout->project()->transformContext() );
629 da.setEllipsoid( mLayout->project()->ellipsoid() );
630
632
633 QList< double > yValues;
634 switch ( mMethod )
635 {
637 yValues << mapExtent.yMaximum();
638 break;
639
641 yValues << 0.5 * ( mapExtent.yMaximum() + mapExtent.yMinimum() );
642 break;
643
644
646 yValues << mapExtent.yMinimum();
647 break;
648
650 yValues << mapExtent.yMaximum();
651 yValues << 0.5 * ( mapExtent.yMaximum() + mapExtent.yMinimum() );
652 yValues << mapExtent.yMinimum();
653 break;
654 }
655
656 double sumValidMeasures = 0;
657 int validMeasureCount = 0;
658
659 for ( const double y : std::as_const( yValues ) )
660 {
661 try
662 {
663 double measure = da.measureLine( QgsPointXY( mapExtent.xMinimum(), y ),
664 QgsPointXY( mapExtent.xMaximum(), y ) );
665 if ( std::isnan( measure ) )
666 {
667 // TODO report errors to user
668 QgsDebugError( QStringLiteral( "An error occurred while calculating length" ) );
669 continue;
670 }
671
672 measure /= QgsUnitTypes::fromUnitToUnitFactor( mSettings.units(), units );
673 sumValidMeasures += measure;
674 validMeasureCount++;
675 }
676 catch ( QgsCsException & )
677 {
678 // TODO report errors to user
679 QgsDebugError( QStringLiteral( "An error occurred while calculating length" ) );
680 continue;
681 }
682 }
683
684 if ( validMeasureCount == 0 )
685 return std::numeric_limits< double >::quiet_NaN();
686
687 return sumValidMeasures / validMeasureCount;
688 }
689}
690
691QgsScaleBarRenderer::ScaleBarContext QgsLayoutItemScaleBar::createScaleContext() const
692{
694 scaleContext.size = rect().size();
695 scaleContext.segmentWidth = mSegmentMillimeters;
696 scaleContext.scale = mMap ? mMap->scale() : 1.0;
697 scaleContext.flags = mStyle->flags();
698 return scaleContext;
699}
700
707
714
716{
717 mSettings.setAlignment( a );
719 emit changed();
720}
721
723{
724 mSettings.setUnits( u );
725 refreshSegmentMillimeters();
727 emit changed();
728}
729
731{
733 return mSettings.lineJoinStyle();
735}
736
737void QgsLayoutItemScaleBar::setLineJoinStyle( Qt::PenJoinStyle style )
738{
740 if ( mSettings.lineJoinStyle() == style )
741 {
742 //no change
743 return;
744 }
745 mSettings.setLineJoinStyle( style );
747 update();
748 emit changed();
749}
750
752{
754 return mSettings.lineCapStyle();
756}
757
758void QgsLayoutItemScaleBar::setLineCapStyle( Qt::PenCapStyle style )
759{
761 if ( mSettings.lineCapStyle() == style )
762 {
763 //no change
764 return;
765 }
766 mSettings.setLineCapStyle( style );
768 update();
769 emit changed();
770}
771
773{
774 //style
775 mStyle = std::make_unique< QgsSingleBoxScaleBarRenderer >();
776
777 //default to no background
778 setBackgroundEnabled( false );
779
780 //get default composer font from settings
781 const QgsSettings settings;
782 const QString defaultFontString = settings.value( QStringLiteral( "LayoutDesigner/defaultFont" ), QVariant(), QgsSettings::Gui ).toString();
783 QgsTextFormat format;
784 QFont f;
785 if ( !defaultFontString.isEmpty() )
786 {
787 QgsFontUtils::setFontFamily( f, defaultFontString );
788 }
789 format.setFont( f );
790 format.setSize( 12.0 );
792
793 mSettings.setTextFormat( format );
794
797
798 emit changed();
799}
800
802{
803 return renderer->applyDefaultSettings( mSettings );
804}
805
807{
808 if ( !mMap )
810
811 const QgsCoordinateReferenceSystem crs = mMap->crs();
812 // start with crs units
815 {
816 // geographic CRS, use metric units
818 }
819
820 // try to pick reasonable choice between metric / imperial units
821 const double widthInSelectedUnits = mapWidth();
822 if ( std::isnan( widthInSelectedUnits ) )
823 return unit;
824
825 const double initialUnitsPerSegment = widthInSelectedUnits / 10.0; //default scalebar width equals half the map width
826 switch ( unit )
827 {
829 {
830 if ( initialUnitsPerSegment > 1000.0 )
831 {
833 }
834 break;
835 }
837 {
838 if ( initialUnitsPerSegment > 5419.95 )
839 {
841 }
842 break;
843 }
844 default:
845 break;
846 }
847
848 return unit;
849}
850
852{
853 mSettings.setUnits( units );
854 if ( mMap )
855 {
856 double upperMagnitudeMultiplier = 1.0;
857 const double widthInSelectedUnits = mapWidth();
858 if ( !std::isnan( widthInSelectedUnits ) )
859 {
860 const double initialUnitsPerSegment = widthInSelectedUnits / 10.0; //default scalebar width equals half the map width
861 mSettings.setUnitsPerSegment( initialUnitsPerSegment );
862
864 upperMagnitudeMultiplier = 1;
865
866 const double segmentWidth = initialUnitsPerSegment / upperMagnitudeMultiplier;
867 const int segmentMagnitude = std::floor( std::log10( segmentWidth ) );
868 double unitsPerSegment = upperMagnitudeMultiplier * ( std::pow( 10.0, segmentMagnitude ) );
869 const double multiplier = std::floor( ( widthInSelectedUnits / ( unitsPerSegment * 10.0 ) ) / 2.5 ) * 2.5;
870
871 if ( multiplier > 0 )
872 {
873 unitsPerSegment = unitsPerSegment * multiplier;
874 }
876 mSettings.setMapUnitsPerScaleBarUnit( upperMagnitudeMultiplier );
877
878 mSettings.setNumberOfSegments( 2 );
879 mSettings.setNumberOfSegmentsLeft( 0 );
880 }
881 }
882
883 refreshSegmentMillimeters();
885 emit changed();
886}
887
889{
890 if ( !mStyle )
891 return;
892
894
895 const QgsScaleBarRenderer::ScaleBarContext scaleContext = createScaleContext();
896 if ( !scaleContext.isValid() )
897 return;
898
899 const double widthMM = mStyle->calculateBoxSize( context, mSettings, scaleContext ).width();
900 QgsLayoutSize currentSize = sizeWithUnits();
901 currentSize.setWidth( mLayout->renderContext().measurementConverter().convert( QgsLayoutMeasurement( widthMM, Qgis::LayoutUnit::Millimeters ), currentSize.units() ).length() );
902 attemptResize( currentSize );
903 update();
904 emit changed();
905}
906
908{
909 //Don't adjust box size for numeric scale bars:
910 if ( mStyle && mStyle->id() != QLatin1String( "Numeric" ) )
911 {
913 }
914 QgsLayoutItem::update();
915}
916
917void QgsLayoutItemScaleBar::updateScale()
918{
919 refreshSegmentMillimeters();
920 //Don't adjust box size for numeric scale bars:
921 if ( mStyle && mStyle->id() != QLatin1String( "Numeric" ) )
922 {
924 }
925 update();
926}
927
928void QgsLayoutItemScaleBar::setStyle( const QString &styleName )
929{
930 //switch depending on style name
931 std::unique_ptr< QgsScaleBarRenderer> renderer( QgsApplication::scaleBarRendererRegistry()->renderer( styleName ) );
932 if ( renderer )
933 {
934 mStyle = std::move( renderer );
935 }
937 emit changed();
938}
939
941{
942 if ( mStyle )
943 {
944 return mStyle->id();
945 }
946 else
947 {
948 return QString();
949 }
950}
951
953{
954 return mSettings.numericFormat();
955}
956
958{
959 mSettings.setNumericFormat( format );
960}
961
963{
964 return mSettings.textFormat().font();
965}
966
967void QgsLayoutItemScaleBar::setFont( const QFont &font )
968{
970 mSettings.setFont( font );
973 emit changed();
974}
975
977{
978 QColor color = mSettings.textFormat().color();
979 color.setAlphaF( mSettings.textFormat().opacity() );
980 return color;
981}
982
983void QgsLayoutItemScaleBar::setFontColor( const QColor &color )
984{
985 mSettings.textFormat().setColor( color );
986 mSettings.textFormat().setOpacity( color.alphaF() );
987}
988
995
996void QgsLayoutItemScaleBar::setFillColor( const QColor &color )
997{
999 mSettings.setFillColor( color );
1001}
1002
1004{
1006 return mSettings.fillColor2();
1008}
1009
1010void QgsLayoutItemScaleBar::setFillColor2( const QColor &color )
1011{
1013 mSettings.setFillColor2( color );
1015}
1016
1018{
1020 return mSettings.lineColor();
1022}
1023
1024void QgsLayoutItemScaleBar::setLineColor( const QColor &color )
1025{
1027 mSettings.setLineColor( color );
1029}
1030
1032{
1034 return mSettings.lineWidth();
1036}
1037
1039{
1041 mSettings.setLineWidth( width );
1043}
1044
1046{
1048 return mSettings.pen();
1050}
1051
1053{
1055 return mSettings.brush();
1057}
1058
1060{
1062 return mSettings.brush2();
1064}
1065
1066bool QgsLayoutItemScaleBar::writePropertiesToElement( QDomElement &composerScaleBarElem, QDomDocument &doc, const QgsReadWriteContext &rwContext ) const
1067{
1068 composerScaleBarElem.setAttribute( QStringLiteral( "height" ), QString::number( mSettings.height() ) );
1069 composerScaleBarElem.setAttribute( QStringLiteral( "labelBarSpace" ), QString::number( mSettings.labelBarSpace() ) );
1070 composerScaleBarElem.setAttribute( QStringLiteral( "boxContentSpace" ), QString::number( mSettings.boxContentSpace() ) );
1071 composerScaleBarElem.setAttribute( QStringLiteral( "numSegments" ), mSettings.numberOfSegments() );
1072 composerScaleBarElem.setAttribute( QStringLiteral( "numSegmentsLeft" ), mSettings.numberOfSegmentsLeft() );
1073 composerScaleBarElem.setAttribute( QStringLiteral( "numSubdivisions" ), mSettings.numberOfSubdivisions() );
1074 composerScaleBarElem.setAttribute( QStringLiteral( "subdivisionsHeight" ), mSettings.subdivisionsHeight() );
1075 composerScaleBarElem.setAttribute( QStringLiteral( "numUnitsPerSegment" ), QString::number( mSettings.unitsPerSegment() ) );
1076 composerScaleBarElem.setAttribute( QStringLiteral( "segmentSizeMode" ), static_cast< int >( mSettings.segmentSizeMode() ) );
1077 composerScaleBarElem.setAttribute( QStringLiteral( "minBarWidth" ), mSettings.minimumBarWidth() );
1078 composerScaleBarElem.setAttribute( QStringLiteral( "maxBarWidth" ), mSettings.maximumBarWidth() );
1079 composerScaleBarElem.setAttribute( QStringLiteral( "segmentMillimeters" ), QString::number( mSegmentMillimeters ) );
1080 composerScaleBarElem.setAttribute( QStringLiteral( "numMapUnitsPerScaleBarUnit" ), QString::number( mSettings.mapUnitsPerScaleBarUnit() ) );
1081 composerScaleBarElem.setAttribute( QStringLiteral( "method" ), qgsEnumValueToKey( mMethod ) );
1082
1083 const QDomElement textElem = mSettings.textFormat().writeXml( doc, rwContext );
1084 composerScaleBarElem.appendChild( textElem );
1085
1087 // kept just for allowing projects to open in QGIS < 3.14, remove for 4.0
1088 composerScaleBarElem.setAttribute( QStringLiteral( "outlineWidth" ), QString::number( mSettings.lineWidth() ) );
1089 composerScaleBarElem.setAttribute( QStringLiteral( "lineJoinStyle" ), QgsSymbolLayerUtils::encodePenJoinStyle( mSettings.lineJoinStyle() ) );
1090 composerScaleBarElem.setAttribute( QStringLiteral( "lineCapStyle" ), QgsSymbolLayerUtils::encodePenCapStyle( mSettings.lineCapStyle() ) );
1091 //pen color
1092 QDomElement strokeColorElem = doc.createElement( QStringLiteral( "strokeColor" ) );
1093 strokeColorElem.setAttribute( QStringLiteral( "red" ), QString::number( mSettings.lineColor().red() ) );
1094 strokeColorElem.setAttribute( QStringLiteral( "green" ), QString::number( mSettings.lineColor().green() ) );
1095 strokeColorElem.setAttribute( QStringLiteral( "blue" ), QString::number( mSettings.lineColor().blue() ) );
1096 strokeColorElem.setAttribute( QStringLiteral( "alpha" ), QString::number( mSettings.lineColor().alpha() ) );
1097 composerScaleBarElem.appendChild( strokeColorElem );
1099
1100 composerScaleBarElem.setAttribute( QStringLiteral( "unitLabel" ), mSettings.unitLabel() );
1101 composerScaleBarElem.setAttribute( QStringLiteral( "unitType" ), QgsUnitTypes::encodeUnit( mSettings.units() ) );
1102
1103 QDomElement numericFormatElem = doc.createElement( QStringLiteral( "numericFormat" ) );
1104 mSettings.numericFormat()->writeXml( numericFormatElem, doc, rwContext );
1105 composerScaleBarElem.appendChild( numericFormatElem );
1106
1107 //style
1108 if ( mStyle )
1109 {
1110 composerScaleBarElem.setAttribute( QStringLiteral( "style" ), mStyle->id() );
1111 }
1112
1113 //map id
1114 if ( mMap )
1115 {
1116 composerScaleBarElem.setAttribute( QStringLiteral( "mapUuid" ), mMap->uuid() );
1117 }
1118
1119 //colors
1120
1122 // kept just for allowing projects to open in QGIS < 3.14, remove for 4.0
1123
1124 //fill color
1125 QDomElement fillColorElem = doc.createElement( QStringLiteral( "fillColor" ) );
1126 fillColorElem.setAttribute( QStringLiteral( "red" ), QString::number( mSettings.fillColor().red() ) );
1127 fillColorElem.setAttribute( QStringLiteral( "green" ), QString::number( mSettings.fillColor().green() ) );
1128 fillColorElem.setAttribute( QStringLiteral( "blue" ), QString::number( mSettings.fillColor().blue() ) );
1129 fillColorElem.setAttribute( QStringLiteral( "alpha" ), QString::number( mSettings.fillColor().alpha() ) );
1130 composerScaleBarElem.appendChild( fillColorElem );
1131
1132 //fill color 2
1133 QDomElement fillColor2Elem = doc.createElement( QStringLiteral( "fillColor2" ) );
1134 fillColor2Elem.setAttribute( QStringLiteral( "red" ), QString::number( mSettings.fillColor2().red() ) );
1135 fillColor2Elem.setAttribute( QStringLiteral( "green" ), QString::number( mSettings.fillColor2().green() ) );
1136 fillColor2Elem.setAttribute( QStringLiteral( "blue" ), QString::number( mSettings.fillColor2().blue() ) );
1137 fillColor2Elem.setAttribute( QStringLiteral( "alpha" ), QString::number( mSettings.fillColor2().alpha() ) );
1138 composerScaleBarElem.appendChild( fillColor2Elem );
1139
1141
1142 //label vertical/horizontal placement
1143 composerScaleBarElem.setAttribute( QStringLiteral( "labelVerticalPlacement" ), QString::number( static_cast< int >( mSettings.labelVerticalPlacement() ) ) );
1144 composerScaleBarElem.setAttribute( QStringLiteral( "labelHorizontalPlacement" ), QString::number( static_cast< int >( mSettings.labelHorizontalPlacement() ) ) );
1145
1146 //alignment
1147 composerScaleBarElem.setAttribute( QStringLiteral( "alignment" ), QString::number( static_cast< int >( mSettings.alignment() ) ) );
1148
1149 QDomElement lineSymbol = doc.createElement( QStringLiteral( "lineSymbol" ) );
1150 const QDomElement symbolElem = QgsSymbolLayerUtils::saveSymbol( QString(),
1151 mSettings.lineSymbol(),
1152 doc,
1153 rwContext );
1154 lineSymbol.appendChild( symbolElem );
1155 composerScaleBarElem.appendChild( lineSymbol );
1156
1157 QDomElement divisionSymbol = doc.createElement( QStringLiteral( "divisionLineSymbol" ) );
1158 const QDomElement divisionSymbolElem = QgsSymbolLayerUtils::saveSymbol( QString(),
1159 mSettings.divisionLineSymbol(),
1160 doc,
1161 rwContext );
1162 divisionSymbol.appendChild( divisionSymbolElem );
1163 composerScaleBarElem.appendChild( divisionSymbol );
1164
1165 QDomElement subdivisionSymbol = doc.createElement( QStringLiteral( "subdivisionLineSymbol" ) );
1166 const QDomElement subdivisionSymbolElem = QgsSymbolLayerUtils::saveSymbol( QString(),
1167 mSettings.subdivisionLineSymbol(),
1168 doc,
1169 rwContext );
1170 subdivisionSymbol.appendChild( subdivisionSymbolElem );
1171 composerScaleBarElem.appendChild( subdivisionSymbol );
1172
1173 QDomElement fillSymbol1Elem = doc.createElement( QStringLiteral( "fillSymbol1" ) );
1174 const QDomElement symbol1Elem = QgsSymbolLayerUtils::saveSymbol( QString(),
1175 mSettings.fillSymbol(),
1176 doc,
1177 rwContext );
1178 fillSymbol1Elem.appendChild( symbol1Elem );
1179 composerScaleBarElem.appendChild( fillSymbol1Elem );
1180
1181 QDomElement fillSymbol2Elem = doc.createElement( QStringLiteral( "fillSymbol2" ) );
1182 const QDomElement symbol2Elem = QgsSymbolLayerUtils::saveSymbol( QString(),
1183 mSettings.alternateFillSymbol(),
1184 doc,
1185 rwContext );
1186 fillSymbol2Elem.appendChild( symbol2Elem );
1187 composerScaleBarElem.appendChild( fillSymbol2Elem );
1188
1189 return true;
1190}
1191
1192
1193bool QgsLayoutItemScaleBar::readPropertiesFromElement( const QDomElement &itemElem, const QDomDocument &, const QgsReadWriteContext &context )
1194{
1195 mSettings.setHeight( itemElem.attribute( QStringLiteral( "height" ), QStringLiteral( "5.0" ) ).toDouble() );
1196 mSettings.setLabelBarSpace( itemElem.attribute( QStringLiteral( "labelBarSpace" ), QStringLiteral( "3.0" ) ).toDouble() );
1197 mSettings.setBoxContentSpace( itemElem.attribute( QStringLiteral( "boxContentSpace" ), QStringLiteral( "1.0" ) ).toDouble() );
1198 mSettings.setNumberOfSegments( itemElem.attribute( QStringLiteral( "numSegments" ), QStringLiteral( "2" ) ).toInt() );
1199 mSettings.setNumberOfSegmentsLeft( itemElem.attribute( QStringLiteral( "numSegmentsLeft" ), QStringLiteral( "0" ) ).toInt() );
1200 mSettings.setNumberOfSubdivisions( itemElem.attribute( QStringLiteral( "numSubdivisions" ), QStringLiteral( "1" ) ).toInt() );
1201 mSettings.setSubdivisionsHeight( itemElem.attribute( QStringLiteral( "subdivisionsHeight" ), QStringLiteral( "1.5" ) ).toDouble() );
1202 mSettings.setUnitsPerSegment( itemElem.attribute( QStringLiteral( "numUnitsPerSegment" ), QStringLiteral( "1.0" ) ).toDouble() );
1203 mSettings.setSegmentSizeMode( static_cast<Qgis::ScaleBarSegmentSizeMode >( itemElem.attribute( QStringLiteral( "segmentSizeMode" ), QStringLiteral( "0" ) ).toInt() ) );
1204 mSettings.setMinimumBarWidth( itemElem.attribute( QStringLiteral( "minBarWidth" ), QStringLiteral( "50" ) ).toDouble() );
1205 mSettings.setMaximumBarWidth( itemElem.attribute( QStringLiteral( "maxBarWidth" ), QStringLiteral( "150" ) ).toDouble() );
1206 mSegmentMillimeters = itemElem.attribute( QStringLiteral( "segmentMillimeters" ), QStringLiteral( "0.0" ) ).toDouble();
1207 mSettings.setMapUnitsPerScaleBarUnit( itemElem.attribute( QStringLiteral( "numMapUnitsPerScaleBarUnit" ), QStringLiteral( "1.0" ) ).toDouble() );
1208
1209 // default to horizontal bottom to keep same behavior for older projects
1210 mMethod = qgsEnumKeyToValue( itemElem.attribute( QStringLiteral( "method" ) ), Qgis::ScaleCalculationMethod::HorizontalBottom );
1211
1212 const QDomElement lineSymbolElem = itemElem.firstChildElement( QStringLiteral( "lineSymbol" ) );
1213 bool foundLineSymbol = false;
1214 if ( !lineSymbolElem.isNull() )
1215 {
1216 const QDomElement symbolElem = lineSymbolElem.firstChildElement( QStringLiteral( "symbol" ) );
1217 std::unique_ptr< QgsLineSymbol > lineSymbol( QgsSymbolLayerUtils::loadSymbol<QgsLineSymbol>( symbolElem, context ) );
1218 if ( lineSymbol )
1219 {
1220 mSettings.setLineSymbol( lineSymbol.release() );
1221 foundLineSymbol = true;
1222 }
1223 }
1224 const QDomElement divisionSymbolElem = itemElem.firstChildElement( QStringLiteral( "divisionLineSymbol" ) );
1225 if ( !divisionSymbolElem.isNull() )
1226 {
1227 const QDomElement symbolElem = divisionSymbolElem.firstChildElement( QStringLiteral( "symbol" ) );
1228 std::unique_ptr< QgsLineSymbol > lineSymbol( QgsSymbolLayerUtils::loadSymbol<QgsLineSymbol>( symbolElem, context ) );
1229 if ( lineSymbol )
1230 {
1231 mSettings.setDivisionLineSymbol( lineSymbol.release() );
1232 }
1233 }
1234 else if ( foundLineSymbol )
1235 {
1236 mSettings.setDivisionLineSymbol( mSettings.lineSymbol()->clone() );
1237 }
1238 const QDomElement subdivisionSymbolElem = itemElem.firstChildElement( QStringLiteral( "subdivisionLineSymbol" ) );
1239 if ( !subdivisionSymbolElem.isNull() )
1240 {
1241 const QDomElement symbolElem = subdivisionSymbolElem.firstChildElement( QStringLiteral( "symbol" ) );
1242 std::unique_ptr< QgsLineSymbol > lineSymbol( QgsSymbolLayerUtils::loadSymbol<QgsLineSymbol>( symbolElem, context ) );
1243 if ( lineSymbol )
1244 {
1245 mSettings.setSubdivisionLineSymbol( lineSymbol.release() );
1246 }
1247 }
1248 else if ( foundLineSymbol )
1249 {
1250 mSettings.setSubdivisionLineSymbol( mSettings.lineSymbol()->clone() );
1251 }
1252
1253 if ( !foundLineSymbol )
1254 {
1255 // old project compatibility
1256 std::unique_ptr< QgsLineSymbol > lineSymbol = std::make_unique< QgsLineSymbol >();
1257 std::unique_ptr< QgsSimpleLineSymbolLayer > lineSymbolLayer = std::make_unique< QgsSimpleLineSymbolLayer >();
1258 lineSymbolLayer->setWidth( itemElem.attribute( QStringLiteral( "outlineWidth" ), QStringLiteral( "0.3" ) ).toDouble() );
1259 lineSymbolLayer->setWidthUnit( Qgis::RenderUnit::Millimeters );
1260 lineSymbolLayer->setPenJoinStyle( QgsSymbolLayerUtils::decodePenJoinStyle( itemElem.attribute( QStringLiteral( "lineJoinStyle" ), QStringLiteral( "miter" ) ) ) );
1261 lineSymbolLayer->setPenCapStyle( QgsSymbolLayerUtils::decodePenCapStyle( itemElem.attribute( QStringLiteral( "lineCapStyle" ), QStringLiteral( "square" ) ) ) );
1262
1263 //stroke color
1264 const QDomNodeList strokeColorList = itemElem.elementsByTagName( QStringLiteral( "strokeColor" ) );
1265 if ( !strokeColorList.isEmpty() )
1266 {
1267 const QDomElement strokeColorElem = strokeColorList.at( 0 ).toElement();
1268 bool redOk, greenOk, blueOk, alphaOk;
1269 int strokeRed, strokeGreen, strokeBlue, strokeAlpha;
1270
1271 strokeRed = strokeColorElem.attribute( QStringLiteral( "red" ) ).toDouble( &redOk );
1272 strokeGreen = strokeColorElem.attribute( QStringLiteral( "green" ) ).toDouble( &greenOk );
1273 strokeBlue = strokeColorElem.attribute( QStringLiteral( "blue" ) ).toDouble( &blueOk );
1274 strokeAlpha = strokeColorElem.attribute( QStringLiteral( "alpha" ) ).toDouble( &alphaOk );
1275
1276 if ( redOk && greenOk && blueOk && alphaOk )
1277 {
1278 lineSymbolLayer->setColor( QColor( strokeRed, strokeGreen, strokeBlue, strokeAlpha ) );
1279 }
1280 }
1281 else
1282 {
1283 lineSymbolLayer->setColor( QColor( itemElem.attribute( QStringLiteral( "penColor" ), QStringLiteral( "#000000" ) ) ) );
1284 }
1285
1286 // need to translate the deprecated ScalebarLineWidth and ScalebarLineColor properties to symbol properties,
1287 // and then remove them from the scalebar so they don't interfere and apply to other compatibility workarounds
1292
1293 lineSymbol->changeSymbolLayer( 0, lineSymbolLayer.release() );
1294 mSettings.setLineSymbol( lineSymbol->clone() );
1295 mSettings.setDivisionLineSymbol( lineSymbol->clone() );
1296 mSettings.setSubdivisionLineSymbol( lineSymbol.release() );
1297 }
1298
1299 mSettings.setUnitLabel( itemElem.attribute( QStringLiteral( "unitLabel" ) ) );
1300
1301 const QDomNodeList textFormatNodeList = itemElem.elementsByTagName( QStringLiteral( "text-style" ) );
1302 if ( !textFormatNodeList.isEmpty() )
1303 {
1304 const QDomElement textFormatElem = textFormatNodeList.at( 0 ).toElement();
1305 mSettings.textFormat().readXml( textFormatElem, context );
1306 }
1307 else
1308 {
1309 QFont f;
1310 if ( !QgsFontUtils::setFromXmlChildNode( f, itemElem, QStringLiteral( "scaleBarFont" ) ) )
1311 {
1312 f.fromString( itemElem.attribute( QStringLiteral( "font" ), QString() ) );
1313 }
1314 mSettings.textFormat().setFont( f );
1315 if ( f.pointSizeF() > 0 )
1316 {
1317 mSettings.textFormat().setSize( f.pointSizeF() );
1319 }
1320 else if ( f.pixelSize() > 0 )
1321 {
1322 mSettings.textFormat().setSize( f.pixelSize() );
1324 }
1325 }
1326
1327 const QDomNodeList numericFormatNodeList = itemElem.elementsByTagName( QStringLiteral( "numericFormat" ) );
1328 if ( !numericFormatNodeList.isEmpty() )
1329 {
1330 const QDomElement numericFormatElem = numericFormatNodeList.at( 0 ).toElement();
1331 mSettings.setNumericFormat( QgsApplication::numericFormatRegistry()->createFromXml( numericFormatElem, context ) );
1332 }
1333
1334 const QDomElement fillSymbol1Elem = itemElem.firstChildElement( QStringLiteral( "fillSymbol1" ) );
1335 bool foundFillSymbol1 = false;
1336 if ( !fillSymbol1Elem.isNull() )
1337 {
1338 const QDomElement symbolElem = fillSymbol1Elem.firstChildElement( QStringLiteral( "symbol" ) );
1339 std::unique_ptr< QgsFillSymbol > fillSymbol( QgsSymbolLayerUtils::loadSymbol<QgsFillSymbol>( symbolElem, context ) );
1340 if ( fillSymbol )
1341 {
1342 mSettings.setFillSymbol( fillSymbol.release() );
1343 foundFillSymbol1 = true;
1344 }
1345 }
1346 if ( !foundFillSymbol1 )
1347 {
1348 // old project compatibility
1349 std::unique_ptr< QgsFillSymbol > fillSymbol = std::make_unique< QgsFillSymbol >();
1350 std::unique_ptr< QgsSimpleFillSymbolLayer > fillSymbolLayer = std::make_unique< QgsSimpleFillSymbolLayer >();
1351 fillSymbolLayer->setStrokeStyle( Qt::NoPen );
1352
1353 //fill color
1354 const QDomNodeList fillColorList = itemElem.elementsByTagName( QStringLiteral( "fillColor" ) );
1355 if ( !fillColorList.isEmpty() )
1356 {
1357 const QDomElement fillColorElem = fillColorList.at( 0 ).toElement();
1358 bool redOk, greenOk, blueOk, alphaOk;
1359 int fillRed, fillGreen, fillBlue, fillAlpha;
1360
1361 fillRed = fillColorElem.attribute( QStringLiteral( "red" ) ).toDouble( &redOk );
1362 fillGreen = fillColorElem.attribute( QStringLiteral( "green" ) ).toDouble( &greenOk );
1363 fillBlue = fillColorElem.attribute( QStringLiteral( "blue" ) ).toDouble( &blueOk );
1364 fillAlpha = fillColorElem.attribute( QStringLiteral( "alpha" ) ).toDouble( &alphaOk );
1365
1366 if ( redOk && greenOk && blueOk && alphaOk )
1367 {
1368 fillSymbolLayer->setColor( QColor( fillRed, fillGreen, fillBlue, fillAlpha ) );
1369 }
1370 }
1371 else
1372 {
1373 fillSymbolLayer->setColor( QColor( itemElem.attribute( QStringLiteral( "brushColor" ), QStringLiteral( "#000000" ) ) ) );
1374 }
1375
1376 // need to translate the deprecated ScalebarFillColor property to symbol properties,
1377 // and then remove them from the scalebar so they don't interfere and apply to other compatibility workarounds
1380
1381 fillSymbol->changeSymbolLayer( 0, fillSymbolLayer.release() );
1382 mSettings.setFillSymbol( fillSymbol.release() );
1383 }
1384
1385 const QDomElement fillSymbol2Elem = itemElem.firstChildElement( QStringLiteral( "fillSymbol2" ) );
1386 bool foundFillSymbol2 = false;
1387 if ( !fillSymbol2Elem.isNull() )
1388 {
1389 const QDomElement symbolElem = fillSymbol2Elem.firstChildElement( QStringLiteral( "symbol" ) );
1390 std::unique_ptr< QgsFillSymbol > fillSymbol( QgsSymbolLayerUtils::loadSymbol<QgsFillSymbol>( symbolElem, context ) );
1391 if ( fillSymbol )
1392 {
1393 mSettings.setAlternateFillSymbol( fillSymbol.release() );
1394 foundFillSymbol2 = true;
1395 }
1396 }
1397 if ( !foundFillSymbol2 )
1398 {
1399 // old project compatibility
1400 std::unique_ptr< QgsFillSymbol > fillSymbol = std::make_unique< QgsFillSymbol >();
1401 std::unique_ptr< QgsSimpleFillSymbolLayer > fillSymbolLayer = std::make_unique< QgsSimpleFillSymbolLayer >();
1402 fillSymbolLayer->setStrokeStyle( Qt::NoPen );
1403
1404 //fill color 2
1405
1406 const QDomNodeList fillColor2List = itemElem.elementsByTagName( QStringLiteral( "fillColor2" ) );
1407 if ( !fillColor2List.isEmpty() )
1408 {
1409 const QDomElement fillColor2Elem = fillColor2List.at( 0 ).toElement();
1410 bool redOk, greenOk, blueOk, alphaOk;
1411 int fillRed, fillGreen, fillBlue, fillAlpha;
1412
1413 fillRed = fillColor2Elem.attribute( QStringLiteral( "red" ) ).toDouble( &redOk );
1414 fillGreen = fillColor2Elem.attribute( QStringLiteral( "green" ) ).toDouble( &greenOk );
1415 fillBlue = fillColor2Elem.attribute( QStringLiteral( "blue" ) ).toDouble( &blueOk );
1416 fillAlpha = fillColor2Elem.attribute( QStringLiteral( "alpha" ) ).toDouble( &alphaOk );
1417
1418 if ( redOk && greenOk && blueOk && alphaOk )
1419 {
1420 fillSymbolLayer->setColor( QColor( fillRed, fillGreen, fillBlue, fillAlpha ) );
1421 }
1422 }
1423 else
1424 {
1425 fillSymbolLayer->setColor( QColor( itemElem.attribute( QStringLiteral( "brush2Color" ), QStringLiteral( "#ffffff" ) ) ) );
1426 }
1427
1428 // need to translate the deprecated ScalebarFillColor2 property to symbol properties,
1429 // and then remove them from the scalebar so they don't interfere and apply to other compatibility workarounds
1432
1433 fillSymbol->changeSymbolLayer( 0, fillSymbolLayer.release() );
1434 mSettings.setAlternateFillSymbol( fillSymbol.release() );
1435
1436 }
1437
1438 //font color
1439 const QDomNodeList textColorList = itemElem.elementsByTagName( QStringLiteral( "textColor" ) );
1440 if ( !textColorList.isEmpty() )
1441 {
1442 const QDomElement textColorElem = textColorList.at( 0 ).toElement();
1443 bool redOk, greenOk, blueOk, alphaOk;
1444 int textRed, textGreen, textBlue, textAlpha;
1445
1446 textRed = textColorElem.attribute( QStringLiteral( "red" ) ).toDouble( &redOk );
1447 textGreen = textColorElem.attribute( QStringLiteral( "green" ) ).toDouble( &greenOk );
1448 textBlue = textColorElem.attribute( QStringLiteral( "blue" ) ).toDouble( &blueOk );
1449 textAlpha = textColorElem.attribute( QStringLiteral( "alpha" ) ).toDouble( &alphaOk );
1450
1451 if ( redOk && greenOk && blueOk && alphaOk )
1452 {
1453 mSettings.textFormat().setColor( QColor( textRed, textGreen, textBlue, textAlpha ) );
1454 }
1455 }
1456 else if ( itemElem.hasAttribute( QStringLiteral( "fontColor" ) ) )
1457 {
1458 QColor c;
1459 c.setNamedColor( itemElem.attribute( QStringLiteral( "fontColor" ), QStringLiteral( "#000000" ) ) );
1460 mSettings.textFormat().setColor( c );
1461 }
1462
1463 //style
1464 setStyle( itemElem.attribute( QStringLiteral( "style" ), QString() ) );
1465
1466 //call attemptResize after setStyle to ensure the appropriate size limitations are applied
1467 attemptResize( QgsLayoutSize::decodeSize( itemElem.attribute( QStringLiteral( "size" ) ) ) );
1468
1469 if ( itemElem.attribute( QStringLiteral( "unitType" ) ).isEmpty() )
1470 {
1472 switch ( itemElem.attribute( QStringLiteral( "units" ) ).toInt() )
1473 {
1474 case 0:
1476 break;
1477 case 1:
1479 break;
1480 case 2:
1482 break;
1483 case 3:
1485 break;
1486 }
1487 mSettings.setUnits( u );
1488 }
1489 else
1490 {
1491 mSettings.setUnits( QgsUnitTypes::decodeDistanceUnit( itemElem.attribute( QStringLiteral( "unitType" ) ) ) );
1492 }
1493
1494 mSettings.setLabelVerticalPlacement( static_cast< Qgis::ScaleBarDistanceLabelVerticalPlacement >( itemElem.attribute( QStringLiteral( "labelVerticalPlacement" ), QStringLiteral( "0" ) ).toInt() ) );
1495 mSettings.setLabelHorizontalPlacement( static_cast< Qgis::ScaleBarDistanceLabelHorizontalPlacement >( itemElem.attribute( QStringLiteral( "labelHorizontalPlacement" ), QStringLiteral( "0" ) ).toInt() ) );
1496
1497 mSettings.setAlignment( static_cast< Qgis::ScaleBarAlignment >( itemElem.attribute( QStringLiteral( "alignment" ), QStringLiteral( "0" ) ).toInt() ) );
1498
1499 //map
1500 disconnectCurrentMap();
1501 mMap = nullptr;
1502 mMapUuid = itemElem.attribute( QStringLiteral( "mapUuid" ) );
1503 return true;
1504}
1505
1506
1508{
1509 if ( mLayout && !mMapUuid.isEmpty() )
1510 {
1511 disconnectCurrentMap();
1512 mMap = qobject_cast< QgsLayoutItemMap * >( mLayout->itemByUuid( mMapUuid, true ) );
1513 if ( mMap )
1514 {
1515 connect( mMap, &QgsLayoutItemMap::extentChanged, this, &QgsLayoutItemScaleBar::updateScale );
1516 connect( mMap, &QObject::destroyed, this, &QgsLayoutItemScaleBar::disconnectCurrentMap );
1517 }
1518 }
1519
1520 updateScale();
1521}
1522
1524{
1525 QgsStyleTextFormatEntity entity( mSettings.textFormat() );
1526 if ( !visitor->visit( QgsStyleEntityVisitorInterface::StyleLeaf( &entity, uuid(), displayName() ) ) )
1527 return false;
1528
1529 return true;
1530}
1531
ScaleBarDistanceLabelHorizontalPlacement
Scale bar distance label horizontal placement.
Definition qgis.h:4973
ScaleBarDistanceLabelVerticalPlacement
Scale bar distance label vertical placement.
Definition qgis.h:4959
@ Millimeters
Millimeters.
ScaleBarAlignment
Scalebar alignment.
Definition qgis.h:4930
DistanceUnit
Units of distance.
Definition qgis.h:4677
@ Feet
Imperial feet.
@ Miles
Terrestrial miles.
@ Unknown
Unknown distance unit.
@ Degrees
Degrees, for planar geographic CRS distance measurements.
@ NauticalMiles
Nautical miles.
@ Kilometers
Kilometers.
@ Millimeters
Millimeters.
@ Points
Points (e.g., for font sizes)
ScaleCalculationMethod
Scale calculation logic.
Definition qgis.h:4914
@ HorizontalTop
Calculate horizontally, across top of map.
@ HorizontalMiddle
Calculate horizontally, across midle of map.
@ HorizontalAverage
Calculate horizontally, using the average of the top, middle and bottom scales.
@ HorizontalBottom
Calculate horizontally, across bottom of map.
ScaleBarSegmentSizeMode
Modes for setting size for scale bar segments.
Definition qgis.h:4945
@ FitWidth
Scale bar segment size is calculated to fit a size range.
@ Fixed
Scale bar segment size is fixed to a map unit.
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).
Custom exception class for Coordinate Reference System related exceptions.
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.
Qgis::DistanceUnit lengthUnits() const
Returns the units of distance for length calculations made by this object.
bool setEllipsoid(const QString &ellipsoid)
Sets the ellipsoid by its acronym.
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.
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.
static void setFontFamily(QFont &font, const QString &family)
Sets the family for a font object.
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.
Contains settings and helpers relating to a render of a QgsLayoutItem.
QgsRenderContext & renderContext()
Returns a reference to the context's render context.
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.
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 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).
double unitsPerSegment() const
Returns the number of scalebar units per segment.
void setAlignment(Qgis::ScaleBarAlignment alignment)
Sets the scalebar alignment.
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.
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).
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 setAlternateFillSymbol(QgsFillSymbol *symbol)
Sets the secondary fill symbol used to render the scalebar (only used for some scalebar types).
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 setLabelVerticalPlacement(Qgis::ScaleBarDistanceLabelVerticalPlacement placement)
Sets the vertical placement of text labels.
void setLabelHorizontalPlacement(Qgis::ScaleBarDistanceLabelHorizontalPlacement placement)
Sets the horizontal placement of text labels.
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.
Qgis::DistanceUnit units() const
Returns the distance units used by the scalebar.
void refreshDataDefinedProperty(QgsLayoutObject::DataDefinedProperty property=QgsLayoutObject::DataDefinedProperty::AllProperties) override
Refreshes a data defined property for the item by reevaluating the property's value and redrawing the...
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 setUnits(Qgis::DistanceUnit units)
Sets the distance units used by 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.
void setSegmentSizeMode(Qgis::ScaleBarSegmentSizeMode mode)
Sets the size mode for scale bar segments.
QgsLineSymbol * lineSymbol() const
Returns the line symbol used to render the scalebar (only used for some scalebar types).
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.
void setMethod(Qgis::ScaleCalculationMethod method)
Sets the scale calculation method, which determines how the bar's scale will be calculated.
Q_DECL_DEPRECATED void setFont(const QFont &font)
Sets the font used for drawing text in the scalebar.
Qgis::DistanceUnit guessUnits() const
Attempts to guess the most reasonable unit choice for the scalebar, given the current linked map's sc...
void setSubdivisionLineSymbol(QgsLineSymbol *symbol)
Sets the line symbol used to render the scalebar subdivisions (only used for some scalebar types).
void applyDefaultSize(Qgis::DistanceUnit units=Qgis::DistanceUnit::Meters)
Applies the default size to the scale bar (scale bar 1/5 of map item width)
Qgis::ScaleCalculationMethod method() const
Returns the scale calculation method, which determines how the bar's scale will be calculated.
void setNumberOfSubdivisions(int subdivisions)
Sets the number of subdivisions for segments included in the right part of the scalebar (only used fo...
QgsLayoutItemScaleBar(QgsLayout *layout)
Constructor for QgsLayoutItemScaleBar, with the specified parent layout.
Base class for graphical items within a QgsLayout.
virtual void refreshDataDefinedProperty(QgsLayoutObject::DataDefinedProperty property=QgsLayoutObject::DataDefinedProperty::AllProperties)
Refreshes a data defined property for the item by reevaluating the property's value and redrawing the...
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 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.
@ ScalebarRightSegments
Number of segments on the right of 0.
@ ScalebarLineColor
Scalebar line color (deprecated, use data defined properties on scalebar line symbol instead)
@ ScalebarRightSegmentSubdivisions
Number of subdivisions per segment on right of 0.
@ ScalebarMaximumWidth
Scalebar segment maximum width.
@ ScalebarFillColor2
Scalebar secondary fill color (deprecated, use data defined properties on scalebar fill symbol 2 inst...
@ ScalebarSubdivisionHeight
Scalebar subdivision height.
@ ScalebarFillColor
Scalebar fill color (deprecated, use data defined properties on scalebar fill symbol 1 instead)
@ ScalebarLineWidth
Scalebar line width (deprecated, use data defined properties on scalebar line symbol instead)
@ ScalebarLeftSegments
Number of segments on the left of 0.
@ ScalebarSegmentWidth
Scalebar width in map units of a single segment.
@ AllProperties
All properties for item.
This class provides a method of storing sizes, consisting of a width and height, for use in QGIS layo...
static QgsLayoutSize decodeSize(const QString &string)
Decodes a size from a string.
void setWidth(const double width)
Sets the width for the size.
Qgis::LayoutUnit units() const
Returns the units for the size.
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:49
A line symbol type, for rendering LineString and MultiLineString geometries.
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:60
void setProperty(int key, const QgsProperty &property)
Adds a property to the collection and takes ownership of it.
bool isActive(int key) const final
Returns true if the collection contains an active property with the specified key.
A store for object properties.
The class is used as a container of context for various read/write operations on other objects.
A rectangle specified with double values.
double xMinimum
double yMinimum
double xMaximum
double yMaximum
Contains information about the context of a rendering operation.
double convertToPainterUnits(double size, Qgis::RenderUnit unit, const QgsMapUnitScale &scale=QgsMapUnitScale(), Qgis::RenderSubcomponentProperty property=Qgis::RenderSubcomponentProperty::Generic) const
Converts a size from the specified units to painter units (pixels).
QPainter * painter()
Returns the destination QPainter for the render 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.
Qgis::ScaleBarAlignment alignment() const
Returns the scalebar alignment.
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).
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).
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.
void setLabelHorizontalPlacement(Qgis::ScaleBarDistanceLabelHorizontalPlacement placement)
Sets the horizontal placement of text labels.
Qgis::ScaleBarDistanceLabelVerticalPlacement labelVerticalPlacement() const
Returns the vertical placement of text labels.
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.
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.
void setLineSymbol(QgsLineSymbol *symbol)
Sets the line symbol used to render the scalebar (only used for some scalebar types).
void setSegmentSizeMode(Qgis::ScaleBarSegmentSizeMode mode)
Sets the size mode for scale bar segments.
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.
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).
Qgis::ScaleBarSegmentSizeMode segmentSizeMode() const
Returns the size mode for the scale bar segments.
void setLabelVerticalPlacement(Qgis::ScaleBarDistanceLabelVerticalPlacement placement)
Sets the vertical placement of text labels.
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.
void setNumberOfSubdivisions(int subdivisions)
Sets the number of subdivisions for segments included in the right part of the scalebar (only used fo...
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...
Qgis::ScaleBarDistanceLabelHorizontalPlacement labelHorizontalPlacement() const
Returns the horizontal placement of text labels.
Q_DECL_DEPRECATED QColor lineColor() const
Returns the color used for lines in the scalebar.
Qgis::DistanceUnit units() const
Returns the distance units used by the scalebar.
void setLabelBarSpace(double space)
Sets the spacing (in millimeters) between labels and the scalebar.
void setAlignment(Qgis::ScaleBarAlignment alignment)
Sets the scalebar alignment.
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.
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...
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.
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.
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.
void setUnits(Qgis::DistanceUnit units)
Sets the distance units 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:64
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:1459
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)
@ StrokeColor
Stroke color.
@ StrokeWidth
Stroke width.
bool changeSymbolLayer(int index, QgsSymbolLayer *layer)
Deletes the current layer at the specified index and replaces it with layer.
Container for all settings relating to text rendering.
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 setSizeUnit(Qgis::RenderUnit unit)
Sets the units for the size of rendered text.
void setOpacity(double opacity)
Sets the text's opacity.
void readXml(const QDomElement &elem, const QgsReadWriteContext &context)
Read settings from a DOM element.
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.
static Q_INVOKABLE double fromUnitToUnitFactor(Qgis::DistanceUnit fromUnit, Qgis::DistanceUnit toUnit)
Returns the conversion factor between the specified distance units.
static Q_INVOKABLE QString toAbbreviatedString(Qgis::DistanceUnit unit)
Returns a translated abbreviation representing a distance unit.
static Q_INVOKABLE QString encodeUnit(Qgis::DistanceUnit unit)
Encodes a distance unit to a string.
static Q_INVOKABLE Qgis::DistanceUnit decodeDistanceUnit(const QString &string, bool *ok=nullptr)
Decodes a distance unit from a string.
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
T qgsEnumKeyToValue(const QString &key, const T &defaultValue, bool tryValueAsKey=true, bool *returnOk=nullptr)
Returns the value corresponding to the given key of an enum.
Definition qgis.h:6168
#define Q_NOWARN_DEPRECATED_POP
Definition qgis.h:6535
QString qgsEnumValueToKey(const T &value, bool *returnOk=nullptr)
Returns the value for the given key of an enum.
Definition qgis.h:6149
#define Q_NOWARN_DEPRECATED_PUSH
Definition qgis.h:6534
bool qgsDoubleNear(double a, double b, double epsilon=4 *std::numeric_limits< double >::epsilon())
Compare two doubles (but allow some difference)
Definition qgis.h:5958
#define QgsDebugError(str)
Definition qgslogger.h:38
const QgsCoordinateReferenceSystem & crs
Contains parameters regarding scalebar calculations.
Flags flags
Scalebar renderer flags.
QSizeF size
Destination size for scalebar.
bool isValid() const
Returns true if the context has valid settings.
double segmentWidth
The width, in millimeters, of each individual segment drawn.
Contains information relating to the style entity currently being visited.