QGIS API Documentation  3.12.1-BucureČ™ti (121cc00ff0)
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 
17 #include "qgslayoutitemscalebar.h"
18 #include "qgslayoutitemregistry.h"
19 #include "qgslayoutitemmap.h"
20 #include "qgslayout.h"
21 #include "qgslayoututils.h"
22 #include "qgsdistancearea.h"
23 #include "qgsscalebarrenderer.h"
25 #include "qgsmapsettings.h"
29 #include "qgsrectangle.h"
30 #include "qgsproject.h"
31 #include "qgssymbollayerutils.h"
32 #include "qgsfontutils.h"
33 #include "qgsunittypes.h"
34 #include "qgssettings.h"
35 #include "qgsstyleentityvisitor.h"
36 #include "qgsnumericformat.h"
38 
39 #include <QDomDocument>
40 #include <QDomElement>
41 #include <QFontMetricsF>
42 #include <QPainter>
43 
44 #include <cmath>
45 
47  : QgsLayoutItem( layout )
48 {
51 }
52 
54 {
56 }
57 
59 {
60  return QgsApplication::getThemeIcon( QStringLiteral( "/mLayoutItemScaleBar.svg" ) );
61 }
62 
64 {
65  return new QgsLayoutItemScaleBar( layout );
66 }
67 
69 {
70  return QgsLayoutSize( mStyle->calculateBoxSize( mSettings, createScaleContext() ), QgsUnitTypes::LayoutMillimeters );
71 }
72 
74 {
75  if ( !mStyle )
76  return;
77 
78  mStyle->draw( context.renderContext(), mSettings, createScaleContext() );
79 }
80 
82 {
83  if ( !mStyle )
84  {
85  mSettings.setNumberOfSegments( nSegments );
86  return;
87  }
88  mSettings.setNumberOfSegments( nSegments );
90 }
91 
93 {
94  if ( !mStyle )
95  {
96  mSettings.setUnitsPerSegment( units );
97  return;
98  }
99  mSettings.setUnitsPerSegment( units );
100  refreshSegmentMillimeters();
102 }
103 
105 {
106  if ( !mStyle )
107  {
108  mSettings.setSegmentSizeMode( mode );
109  return;
110  }
111  mSettings.setSegmentSizeMode( mode );
112  refreshSegmentMillimeters();
114 }
115 
117 {
118  if ( !mStyle )
119  {
120  mSettings.setMinimumBarWidth( minWidth );
121  return;
122  }
123  mSettings.setMinimumBarWidth( minWidth );
124  refreshSegmentMillimeters();
126 }
127 
129 {
130  if ( !mStyle )
131  {
132  mSettings.setMaximumBarWidth( maxWidth );
133  return;
134  }
135  mSettings.setMaximumBarWidth( maxWidth );
136  refreshSegmentMillimeters();
138 }
139 
141 {
142  return mSettings.textFormat();
143 }
144 
146 {
147  mSettings.setTextFormat( format );
148  refreshItemSize();
149  emit changed();
150 }
151 
153 {
154  if ( !mStyle )
155  {
156  mSettings.setNumberOfSegmentsLeft( nSegmentsLeft );
157  return;
158  }
159  mSettings.setNumberOfSegmentsLeft( nSegmentsLeft );
161 }
162 
164 {
165  if ( !mStyle )
166  {
167  mSettings.setBoxContentSpace( space );
168  return;
169  }
170  mSettings.setBoxContentSpace( space );
171  refreshItemSize();
172 }
173 
175 {
176  disconnectCurrentMap();
177 
178  mMap = map;
179 
180  if ( !map )
181  {
182  return;
183  }
184 
185  connect( mMap, &QgsLayoutItemMap::extentChanged, this, &QgsLayoutItemScaleBar::updateScale );
186  connect( mMap, &QObject::destroyed, this, &QgsLayoutItemScaleBar::disconnectCurrentMap );
187 
188  refreshSegmentMillimeters();
189  emit changed();
190 }
191 
192 void QgsLayoutItemScaleBar::disconnectCurrentMap()
193 {
194  if ( !mMap )
195  {
196  return;
197  }
198 
199  disconnect( mMap, &QgsLayoutItemMap::extentChanged, this, &QgsLayoutItemScaleBar::updateScale );
200  disconnect( mMap, &QObject::destroyed, this, &QgsLayoutItemScaleBar::disconnectCurrentMap );
201  mMap = nullptr;
202 }
203 
205 {
207 
208  bool forceUpdate = false;
209  //updates data defined properties and redraws item to match
211  {
212  QBrush b = mSettings.brush();
214  mSettings.setBrush( b );
215  forceUpdate = true;
216  }
218  {
219  QBrush b = mSettings.brush2();
221  mSettings.setBrush2( b );
222  forceUpdate = true;
223  }
225  {
226  QPen p = mSettings.pen();
228  mSettings.setPen( p );
229  forceUpdate = true;
230  }
232  {
233  QPen p = mSettings.pen();
235  mSettings.setPen( p );
236  forceUpdate = true;
237  }
238  if ( forceUpdate )
239  {
240  refreshItemSize();
241  update();
242  }
243 
245 }
246 
247 void QgsLayoutItemScaleBar::refreshSegmentMillimeters()
248 {
249  if ( mMap )
250  {
251  //get mm dimension of composer map
252  QRectF composerItemRect = mMap->rect();
253 
254  switch ( mSettings.segmentSizeMode() )
255  {
257  {
258  //calculate size depending on mNumUnitsPerSegment
259  mSegmentMillimeters = composerItemRect.width() / mapWidth() * mSettings.unitsPerSegment();
260  break;
261  }
262 
264  {
265  if ( mSettings.maximumBarWidth() < mSettings.minimumBarWidth() )
266  {
267  mSegmentMillimeters = 0;
268  }
269  else
270  {
271  double nSegments = ( mSettings.numberOfSegmentsLeft() != 0 ) + mSettings.numberOfSegments();
272  // unitsPerSegments which fit minBarWidth resp. maxBarWidth
273  double minUnitsPerSeg = ( mSettings.minimumBarWidth() * mapWidth() ) / ( nSegments * composerItemRect.width() );
274  double maxUnitsPerSeg = ( mSettings.maximumBarWidth() * mapWidth() ) / ( nSegments * composerItemRect.width() );
275  mSettings.setUnitsPerSegment( QgsLayoutUtils::calculatePrettySize( minUnitsPerSeg, maxUnitsPerSeg ) );
276  mSegmentMillimeters = composerItemRect.width() / mapWidth() * mSettings.unitsPerSegment();
277  }
278  break;
279  }
280  }
281  }
282 }
283 
284 double QgsLayoutItemScaleBar::mapWidth() const
285 {
286  if ( !mMap )
287  {
288  return 0.0;
289  }
290 
291  QgsRectangle mapExtent = mMap->extent();
292  if ( mSettings.units() == QgsUnitTypes::DistanceUnknownUnit )
293  {
294  return mapExtent.width();
295  }
296  else
297  {
298  QgsDistanceArea da;
299  da.setSourceCrs( mMap->crs(), mLayout->project()->transformContext() );
300  da.setEllipsoid( mLayout->project()->ellipsoid() );
301 
303  double measure = da.measureLine( QgsPointXY( mapExtent.xMinimum(), mapExtent.yMinimum() ),
304  QgsPointXY( mapExtent.xMaximum(), mapExtent.yMinimum() ) );
305  measure /= QgsUnitTypes::fromUnitToUnitFactor( mSettings.units(), units );
306  return measure;
307  }
308 }
309 
310 QgsScaleBarRenderer::ScaleBarContext QgsLayoutItemScaleBar::createScaleContext() const
311 {
313  scaleContext.size = rect().size();
314  scaleContext.segmentWidth = mSegmentMillimeters;
315  scaleContext.scale = mMap ? mMap->scale() : 1.0;
316  return scaleContext;
317 }
318 
320 {
321  mSettings.setLabelVerticalPlacement( placement );
322  refreshItemSize();
323  emit changed();
324 }
325 
327 {
328  mSettings.setLabelHorizontalPlacement( placement );
329  refreshItemSize();
330  emit changed();
331 }
332 
334 {
335  mSettings.setAlignment( a );
336  refreshItemSize();
337  emit changed();
338 }
339 
341 {
342  mSettings.setUnits( u );
343  refreshSegmentMillimeters();
344  refreshItemSize();
345  emit changed();
346 }
347 
349 {
350  if ( mSettings.lineJoinStyle() == style )
351  {
352  //no change
353  return;
354  }
355  mSettings.setLineJoinStyle( style );
356  update();
357  emit changed();
358 }
359 
361 {
362  if ( mSettings.lineCapStyle() == style )
363  {
364  //no change
365  return;
366  }
367  mSettings.setLineCapStyle( style );
368  update();
369  emit changed();
370 }
371 
373 {
374  //style
375  mStyle = qgis::make_unique< QgsSingleBoxScaleBarRenderer >();
376 
377  //default to no background
378  setBackgroundEnabled( false );
379 
380  //get default composer font from settings
381  QgsSettings settings;
382  QString defaultFontString = settings.value( QStringLiteral( "LayoutDesigner/defaultFont" ), QVariant(), QgsSettings::Gui ).toString();
383  QgsTextFormat format;
384  QFont f;
385  if ( !defaultFontString.isEmpty() )
386  {
387  f.setFamily( defaultFontString );
388  }
389  format.setFont( f );
390  format.setSize( 12.0 );
392 
393  mSettings.setTextFormat( format );
394 
396  refreshItemSize();
397 
398  emit changed();
399 }
400 
402 {
403  if ( !mMap )
405 
407  // start with crs units
410  {
411  // geographic CRS, use metric units
413  }
414 
415  // try to pick reasonable choice between metric / imperial units
416  double widthInSelectedUnits = mapWidth();
417  double initialUnitsPerSegment = widthInSelectedUnits / 10.0; //default scalebar width equals half the map width
418  switch ( unit )
419  {
421  {
422  if ( initialUnitsPerSegment > 1000.0 )
423  {
425  }
426  break;
427  }
429  {
430  if ( initialUnitsPerSegment > 5419.95 )
431  {
433  }
434  break;
435  }
436  default:
437  break;
438  }
439 
440  return unit;
441 }
442 
444 {
445  mSettings.setUnits( units );
446  if ( mMap )
447  {
448  double upperMagnitudeMultiplier = 1.0;
449  double widthInSelectedUnits = mapWidth();
450  double initialUnitsPerSegment = widthInSelectedUnits / 10.0; //default scalebar width equals half the map width
451  mSettings.setUnitsPerSegment( initialUnitsPerSegment );
452 
454  upperMagnitudeMultiplier = 1;
455 
456  double segmentWidth = initialUnitsPerSegment / upperMagnitudeMultiplier;
457  int segmentMagnitude = std::floor( std::log10( segmentWidth ) );
458  double unitsPerSegment = upperMagnitudeMultiplier * ( std::pow( 10.0, segmentMagnitude ) );
459  double multiplier = std::floor( ( widthInSelectedUnits / ( unitsPerSegment * 10.0 ) ) / 2.5 ) * 2.5;
460 
461  if ( multiplier > 0 )
462  {
463  unitsPerSegment = unitsPerSegment * multiplier;
464  }
465  mSettings.setUnitsPerSegment( unitsPerSegment );
466  mSettings.setMapUnitsPerScaleBarUnit( upperMagnitudeMultiplier );
467 
468  mSettings.setNumberOfSegments( 2 );
469  mSettings.setNumberOfSegmentsLeft( 0 );
470  }
471 
472  refreshSegmentMillimeters();
474  emit changed();
475 }
476 
478 {
479  if ( !mStyle )
480  return;
481 
482  double widthMM = mStyle->calculateBoxSize( mSettings, createScaleContext() ).width();
483  QgsLayoutSize currentSize = sizeWithUnits();
484  currentSize.setWidth( mLayout->renderContext().measurementConverter().convert( QgsLayoutMeasurement( widthMM, QgsUnitTypes::LayoutMillimeters ), currentSize.units() ).length() );
485  attemptResize( currentSize );
486  update();
487  emit changed();
488 }
489 
491 {
492  //Don't adjust box size for numeric scale bars:
493  if ( mStyle && mStyle->name() != QLatin1String( "Numeric" ) )
494  {
495  refreshItemSize();
496  }
497  QgsLayoutItem::update();
498 }
499 
500 void QgsLayoutItemScaleBar::updateScale()
501 {
502  refreshSegmentMillimeters();
504  update();
505 }
506 
507 void QgsLayoutItemScaleBar::setStyle( const QString &styleName )
508 {
509  //switch depending on style name
510  if ( styleName == QLatin1String( "Single Box" ) )
511  {
512  mStyle = qgis::make_unique< QgsSingleBoxScaleBarRenderer >();
513  }
514  else if ( styleName == QLatin1String( "Double Box" ) )
515  {
516  mStyle = qgis::make_unique< QgsDoubleBoxScaleBarRenderer >();
517  }
518  else if ( styleName == QLatin1String( "Line Ticks Middle" ) || styleName == QLatin1String( "Line Ticks Down" ) || styleName == QLatin1String( "Line Ticks Up" ) )
519  {
520  std::unique_ptr< QgsTicksScaleBarRenderer > tickStyle = qgis::make_unique< QgsTicksScaleBarRenderer >();
521  if ( styleName == QLatin1String( "Line Ticks Middle" ) )
522  {
523  tickStyle->setTickPosition( QgsTicksScaleBarRenderer::TicksMiddle );
524  }
525  else if ( styleName == QLatin1String( "Line Ticks Down" ) )
526  {
527  tickStyle->setTickPosition( QgsTicksScaleBarRenderer::TicksDown );
528  }
529  else if ( styleName == QLatin1String( "Line Ticks Up" ) )
530  {
531  tickStyle->setTickPosition( QgsTicksScaleBarRenderer::TicksUp );
532  }
533  mStyle = std::move( tickStyle );
534  }
535  else if ( styleName == QLatin1String( "Numeric" ) )
536  {
537  mStyle = qgis::make_unique< QgsNumericScaleBarRenderer >();
538  }
539  refreshItemSize();
540  emit changed();
541 }
542 
544 {
545  if ( mStyle )
546  {
547  return mStyle->name();
548  }
549  else
550  {
551  return QString();
552  }
553 }
554 
556 {
557  return mSettings.numericFormat();
558 }
559 
561 {
562  mSettings.setNumericFormat( format );
563 }
564 
566 {
567  return mSettings.textFormat().font();
568 }
569 
571 {
573  mSettings.setFont( font );
575  refreshItemSize();
576  emit changed();
577 }
578 
580 {
581  QColor color = mSettings.textFormat().color();
582  color.setAlphaF( mSettings.textFormat().opacity() );
583  return color;
584 }
585 
586 void QgsLayoutItemScaleBar::setFontColor( const QColor &color )
587 {
588  mSettings.textFormat().setColor( color );
589  mSettings.textFormat().setOpacity( color.alphaF() );
590 }
591 
592 bool QgsLayoutItemScaleBar::writePropertiesToElement( QDomElement &composerScaleBarElem, QDomDocument &doc, const QgsReadWriteContext &rwContext ) const
593 {
594  composerScaleBarElem.setAttribute( QStringLiteral( "height" ), QString::number( mSettings.height() ) );
595  composerScaleBarElem.setAttribute( QStringLiteral( "labelBarSpace" ), QString::number( mSettings.labelBarSpace() ) );
596  composerScaleBarElem.setAttribute( QStringLiteral( "boxContentSpace" ), QString::number( mSettings.boxContentSpace() ) );
597  composerScaleBarElem.setAttribute( QStringLiteral( "numSegments" ), mSettings.numberOfSegments() );
598  composerScaleBarElem.setAttribute( QStringLiteral( "numSegmentsLeft" ), mSettings.numberOfSegmentsLeft() );
599  composerScaleBarElem.setAttribute( QStringLiteral( "numUnitsPerSegment" ), QString::number( mSettings.unitsPerSegment() ) );
600  composerScaleBarElem.setAttribute( QStringLiteral( "segmentSizeMode" ), mSettings.segmentSizeMode() );
601  composerScaleBarElem.setAttribute( QStringLiteral( "minBarWidth" ), mSettings.minimumBarWidth() );
602  composerScaleBarElem.setAttribute( QStringLiteral( "maxBarWidth" ), mSettings.maximumBarWidth() );
603  composerScaleBarElem.setAttribute( QStringLiteral( "segmentMillimeters" ), QString::number( mSegmentMillimeters ) );
604  composerScaleBarElem.setAttribute( QStringLiteral( "numMapUnitsPerScaleBarUnit" ), QString::number( mSettings.mapUnitsPerScaleBarUnit() ) );
605 
606  QDomElement textElem = mSettings.textFormat().writeXml( doc, rwContext );
607  composerScaleBarElem.appendChild( textElem );
608 
609  composerScaleBarElem.setAttribute( QStringLiteral( "outlineWidth" ), QString::number( mSettings.lineWidth() ) );
610  composerScaleBarElem.setAttribute( QStringLiteral( "unitLabel" ), mSettings.unitLabel() );
611  composerScaleBarElem.setAttribute( QStringLiteral( "unitType" ), QgsUnitTypes::encodeUnit( mSettings.units() ) );
612  composerScaleBarElem.setAttribute( QStringLiteral( "lineJoinStyle" ), QgsSymbolLayerUtils::encodePenJoinStyle( mSettings.lineJoinStyle() ) );
613  composerScaleBarElem.setAttribute( QStringLiteral( "lineCapStyle" ), QgsSymbolLayerUtils::encodePenCapStyle( mSettings.lineCapStyle() ) );
614 
615  QDomElement numericFormatElem = doc.createElement( QStringLiteral( "numericFormat" ) );
616  mSettings.numericFormat()->writeXml( numericFormatElem, doc, rwContext );
617  composerScaleBarElem.appendChild( numericFormatElem );
618 
619  //style
620  if ( mStyle )
621  {
622  composerScaleBarElem.setAttribute( QStringLiteral( "style" ), mStyle->name() );
623  }
624 
625  //map id
626  if ( mMap )
627  {
628  composerScaleBarElem.setAttribute( QStringLiteral( "mapUuid" ), mMap->uuid() );
629  }
630 
631  //colors
632 
633  //fill color
634  QDomElement fillColorElem = doc.createElement( QStringLiteral( "fillColor" ) );
635  fillColorElem.setAttribute( QStringLiteral( "red" ), QString::number( mSettings.fillColor().red() ) );
636  fillColorElem.setAttribute( QStringLiteral( "green" ), QString::number( mSettings.fillColor().green() ) );
637  fillColorElem.setAttribute( QStringLiteral( "blue" ), QString::number( mSettings.fillColor().blue() ) );
638  fillColorElem.setAttribute( QStringLiteral( "alpha" ), QString::number( mSettings.fillColor().alpha() ) );
639  composerScaleBarElem.appendChild( fillColorElem );
640 
641  //fill color 2
642  QDomElement fillColor2Elem = doc.createElement( QStringLiteral( "fillColor2" ) );
643  fillColor2Elem.setAttribute( QStringLiteral( "red" ), QString::number( mSettings.fillColor2().red() ) );
644  fillColor2Elem.setAttribute( QStringLiteral( "green" ), QString::number( mSettings.fillColor2().green() ) );
645  fillColor2Elem.setAttribute( QStringLiteral( "blue" ), QString::number( mSettings.fillColor2().blue() ) );
646  fillColor2Elem.setAttribute( QStringLiteral( "alpha" ), QString::number( mSettings.fillColor2().alpha() ) );
647  composerScaleBarElem.appendChild( fillColor2Elem );
648 
649  //pen color
650  QDomElement strokeColorElem = doc.createElement( QStringLiteral( "strokeColor" ) );
651  strokeColorElem.setAttribute( QStringLiteral( "red" ), QString::number( mSettings.lineColor().red() ) );
652  strokeColorElem.setAttribute( QStringLiteral( "green" ), QString::number( mSettings.lineColor().green() ) );
653  strokeColorElem.setAttribute( QStringLiteral( "blue" ), QString::number( mSettings.lineColor().blue() ) );
654  strokeColorElem.setAttribute( QStringLiteral( "alpha" ), QString::number( mSettings.lineColor().alpha() ) );
655  composerScaleBarElem.appendChild( strokeColorElem );
656 
657  //label vertical/horizontal placement
658  composerScaleBarElem.setAttribute( QStringLiteral( "labelVerticalPlacement" ), QString::number( static_cast< int >( mSettings.labelVerticalPlacement() ) ) );
659  composerScaleBarElem.setAttribute( QStringLiteral( "labelHorizontalPlacement" ), QString::number( static_cast< int >( mSettings.labelHorizontalPlacement() ) ) );
660 
661  //alignment
662  composerScaleBarElem.setAttribute( QStringLiteral( "alignment" ), QString::number( static_cast< int >( mSettings.alignment() ) ) );
663 
664  return true;
665 }
666 
667 bool QgsLayoutItemScaleBar::readPropertiesFromElement( const QDomElement &itemElem, const QDomDocument &, const QgsReadWriteContext &context )
668 {
669  mSettings.setHeight( itemElem.attribute( QStringLiteral( "height" ), QStringLiteral( "5.0" ) ).toDouble() );
670  mSettings.setLabelBarSpace( itemElem.attribute( QStringLiteral( "labelBarSpace" ), QStringLiteral( "3.0" ) ).toDouble() );
671  mSettings.setBoxContentSpace( itemElem.attribute( QStringLiteral( "boxContentSpace" ), QStringLiteral( "1.0" ) ).toDouble() );
672  mSettings.setNumberOfSegments( itemElem.attribute( QStringLiteral( "numSegments" ), QStringLiteral( "2" ) ).toInt() );
673  mSettings.setNumberOfSegmentsLeft( itemElem.attribute( QStringLiteral( "numSegmentsLeft" ), QStringLiteral( "0" ) ).toInt() );
674  mSettings.setUnitsPerSegment( itemElem.attribute( QStringLiteral( "numUnitsPerSegment" ), QStringLiteral( "1.0" ) ).toDouble() );
675  mSettings.setSegmentSizeMode( static_cast<QgsScaleBarSettings::SegmentSizeMode>( itemElem.attribute( QStringLiteral( "segmentSizeMode" ), QStringLiteral( "0" ) ).toInt() ) );
676  mSettings.setMinimumBarWidth( itemElem.attribute( QStringLiteral( "minBarWidth" ), QStringLiteral( "50" ) ).toDouble() );
677  mSettings.setMaximumBarWidth( itemElem.attribute( QStringLiteral( "maxBarWidth" ), QStringLiteral( "150" ) ).toDouble() );
678  mSegmentMillimeters = itemElem.attribute( QStringLiteral( "segmentMillimeters" ), QStringLiteral( "0.0" ) ).toDouble();
679  mSettings.setMapUnitsPerScaleBarUnit( itemElem.attribute( QStringLiteral( "numMapUnitsPerScaleBarUnit" ), QStringLiteral( "1.0" ) ).toDouble() );
680  mSettings.setLineWidth( itemElem.attribute( QStringLiteral( "outlineWidth" ), QStringLiteral( "0.3" ) ).toDouble() );
681  mSettings.setUnitLabel( itemElem.attribute( QStringLiteral( "unitLabel" ) ) );
682  mSettings.setLineJoinStyle( QgsSymbolLayerUtils::decodePenJoinStyle( itemElem.attribute( QStringLiteral( "lineJoinStyle" ), QStringLiteral( "miter" ) ) ) );
683  mSettings.setLineCapStyle( QgsSymbolLayerUtils::decodePenCapStyle( itemElem.attribute( QStringLiteral( "lineCapStyle" ), QStringLiteral( "square" ) ) ) );
684 
685  QDomNodeList textFormatNodeList = itemElem.elementsByTagName( QStringLiteral( "text-style" ) );
686  if ( !textFormatNodeList.isEmpty() )
687  {
688  QDomElement textFormatElem = textFormatNodeList.at( 0 ).toElement();
689  mSettings.textFormat().readXml( textFormatElem, context );
690  }
691  else
692  {
693  QFont f;
694  if ( !QgsFontUtils::setFromXmlChildNode( f, itemElem, QStringLiteral( "scaleBarFont" ) ) )
695  {
696  f.fromString( itemElem.attribute( QStringLiteral( "font" ), QString() ) );
697  }
698  mSettings.textFormat().setFont( f );
699  if ( f.pointSizeF() > 0 )
700  {
701  mSettings.textFormat().setSize( f.pointSizeF() );
703  }
704  else if ( f.pixelSize() > 0 )
705  {
706  mSettings.textFormat().setSize( f.pixelSize() );
708  }
709  }
710 
711  QDomNodeList numericFormatNodeList = itemElem.elementsByTagName( QStringLiteral( "numericFormat" ) );
712  if ( !numericFormatNodeList.isEmpty() )
713  {
714  QDomElement numericFormatElem = numericFormatNodeList.at( 0 ).toElement();
715  mSettings.setNumericFormat( QgsApplication::numericFormatRegistry()->createFromXml( numericFormatElem, context ) );
716  }
717 
718  //colors
719  //fill color
720  QDomNodeList fillColorList = itemElem.elementsByTagName( QStringLiteral( "fillColor" ) );
721  if ( !fillColorList.isEmpty() )
722  {
723  QDomElement fillColorElem = fillColorList.at( 0 ).toElement();
724  bool redOk, greenOk, blueOk, alphaOk;
725  int fillRed, fillGreen, fillBlue, fillAlpha;
726 
727  fillRed = fillColorElem.attribute( QStringLiteral( "red" ) ).toDouble( &redOk );
728  fillGreen = fillColorElem.attribute( QStringLiteral( "green" ) ).toDouble( &greenOk );
729  fillBlue = fillColorElem.attribute( QStringLiteral( "blue" ) ).toDouble( &blueOk );
730  fillAlpha = fillColorElem.attribute( QStringLiteral( "alpha" ) ).toDouble( &alphaOk );
731 
732  if ( redOk && greenOk && blueOk && alphaOk )
733  {
734  mSettings.setFillColor( QColor( fillRed, fillGreen, fillBlue, fillAlpha ) );
735  }
736  }
737  else
738  {
739  mSettings.setFillColor( QColor( itemElem.attribute( QStringLiteral( "brushColor" ), QStringLiteral( "#000000" ) ) ) );
740  }
741 
742  //fill color 2
743  QDomNodeList fillColor2List = itemElem.elementsByTagName( QStringLiteral( "fillColor2" ) );
744  if ( !fillColor2List.isEmpty() )
745  {
746  QDomElement fillColor2Elem = fillColor2List.at( 0 ).toElement();
747  bool redOk, greenOk, blueOk, alphaOk;
748  int fillRed, fillGreen, fillBlue, fillAlpha;
749 
750  fillRed = fillColor2Elem.attribute( QStringLiteral( "red" ) ).toDouble( &redOk );
751  fillGreen = fillColor2Elem.attribute( QStringLiteral( "green" ) ).toDouble( &greenOk );
752  fillBlue = fillColor2Elem.attribute( QStringLiteral( "blue" ) ).toDouble( &blueOk );
753  fillAlpha = fillColor2Elem.attribute( QStringLiteral( "alpha" ) ).toDouble( &alphaOk );
754 
755  if ( redOk && greenOk && blueOk && alphaOk )
756  {
757  mSettings.setFillColor2( QColor( fillRed, fillGreen, fillBlue, fillAlpha ) );
758  }
759  }
760  else
761  {
762  mSettings.setFillColor2( QColor( itemElem.attribute( QStringLiteral( "brush2Color" ), QStringLiteral( "#ffffff" ) ) ) );
763  }
764 
765  //stroke color
766  QDomNodeList strokeColorList = itemElem.elementsByTagName( QStringLiteral( "strokeColor" ) );
767  if ( !strokeColorList.isEmpty() )
768  {
769  QDomElement strokeColorElem = strokeColorList.at( 0 ).toElement();
770  bool redOk, greenOk, blueOk, alphaOk;
771  int strokeRed, strokeGreen, strokeBlue, strokeAlpha;
772 
773  strokeRed = strokeColorElem.attribute( QStringLiteral( "red" ) ).toDouble( &redOk );
774  strokeGreen = strokeColorElem.attribute( QStringLiteral( "green" ) ).toDouble( &greenOk );
775  strokeBlue = strokeColorElem.attribute( QStringLiteral( "blue" ) ).toDouble( &blueOk );
776  strokeAlpha = strokeColorElem.attribute( QStringLiteral( "alpha" ) ).toDouble( &alphaOk );
777 
778  if ( redOk && greenOk && blueOk && alphaOk )
779  {
780  mSettings.setLineColor( QColor( strokeRed, strokeGreen, strokeBlue, strokeAlpha ) );
781  QPen p = mSettings.pen();
782  p.setColor( mSettings.lineColor() );
783  mSettings.setPen( p );
784  }
785  }
786  else
787  {
788  mSettings.setLineColor( QColor( itemElem.attribute( QStringLiteral( "penColor" ), QStringLiteral( "#000000" ) ) ) );
789  QPen p = mSettings.pen();
790  p.setColor( mSettings.lineColor() );
791  mSettings.setPen( p );
792  }
793 
794  //font color
795  QDomNodeList textColorList = itemElem.elementsByTagName( QStringLiteral( "textColor" ) );
796  if ( !textColorList.isEmpty() )
797  {
798  QDomElement textColorElem = textColorList.at( 0 ).toElement();
799  bool redOk, greenOk, blueOk, alphaOk;
800  int textRed, textGreen, textBlue, textAlpha;
801 
802  textRed = textColorElem.attribute( QStringLiteral( "red" ) ).toDouble( &redOk );
803  textGreen = textColorElem.attribute( QStringLiteral( "green" ) ).toDouble( &greenOk );
804  textBlue = textColorElem.attribute( QStringLiteral( "blue" ) ).toDouble( &blueOk );
805  textAlpha = textColorElem.attribute( QStringLiteral( "alpha" ) ).toDouble( &alphaOk );
806 
807  if ( redOk && greenOk && blueOk && alphaOk )
808  {
809  mSettings.textFormat().setColor( QColor( textRed, textGreen, textBlue, textAlpha ) );
810  }
811  }
812  else if ( itemElem.hasAttribute( QStringLiteral( "fontColor" ) ) )
813  {
814  QColor c;
815  c.setNamedColor( itemElem.attribute( QStringLiteral( "fontColor" ), QStringLiteral( "#000000" ) ) );
816  mSettings.textFormat().setColor( c );
817  }
818 
819  //style
820  QString styleString = itemElem.attribute( QStringLiteral( "style" ), QString() );
821  setStyle( styleString.toLocal8Bit().data() );
822 
823  if ( itemElem.attribute( QStringLiteral( "unitType" ) ).isEmpty() )
824  {
826  switch ( itemElem.attribute( QStringLiteral( "units" ) ).toInt() )
827  {
828  case 0:
830  break;
831  case 1:
833  break;
834  case 2:
836  break;
837  case 3:
839  break;
840  }
841  mSettings.setUnits( u );
842  }
843  else
844  {
845  mSettings.setUnits( QgsUnitTypes::decodeDistanceUnit( itemElem.attribute( QStringLiteral( "unitType" ) ) ) );
846  }
847 
848  mSettings.setLabelVerticalPlacement( static_cast< QgsScaleBarSettings::LabelVerticalPlacement >( itemElem.attribute( QStringLiteral( "labelVerticalPlacement" ), QStringLiteral( "0" ) ).toInt() ) );
849  mSettings.setLabelHorizontalPlacement( static_cast< QgsScaleBarSettings::LabelHorizontalPlacement >( itemElem.attribute( QStringLiteral( "labelHorizontalPlacement" ), QStringLiteral( "0" ) ).toInt() ) );
850 
851  mSettings.setAlignment( static_cast< QgsScaleBarSettings::Alignment >( itemElem.attribute( QStringLiteral( "alignment" ), QStringLiteral( "0" ) ).toInt() ) );
852 
853  //map
854  disconnectCurrentMap();
855  mMap = nullptr;
856  mMapUuid = itemElem.attribute( QStringLiteral( "mapUuid" ) );
857  return true;
858 }
859 
860 
862 {
863  if ( mLayout && !mMapUuid.isEmpty() )
864  {
865  disconnectCurrentMap();
866  mMap = qobject_cast< QgsLayoutItemMap * >( mLayout->itemByUuid( mMapUuid, true ) );
867  if ( mMap )
868  {
869  connect( mMap, &QgsLayoutItemMap::extentChanged, this, &QgsLayoutItemScaleBar::updateScale );
870  connect( mMap, &QObject::destroyed, this, &QgsLayoutItemScaleBar::disconnectCurrentMap );
871  }
872  }
873 
874  updateScale();
875 }
876 
878 {
879  QgsStyleTextFormatEntity entity( mSettings.textFormat() );
880  if ( !visitor->visit( QgsStyleEntityVisitorInterface::StyleLeaf( &entity, uuid(), displayName() ) ) )
881  return false;
882 
883  return true;
884 }
885 
887 {
889 }
QgsUnitTypes::DistanceUnit guessUnits() const
Attempts to guess the most reasonable unit choice for the scalebar, given the current linked map&#39;s sc...
QgsUnitTypes::DistanceUnit lengthUnits() const
Returns the units of distance for length calculations made by this object.
The class is used as a container of context for various read/write operations on other objects...
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...
QgsExpressionContext createExpressionContext() const override
This method needs to be reimplemented in all classes which implement this interface and return an exp...
void setMinimumBarWidth(double width)
Sets the minimum width (in millimeters) for scale bar segments.
A rectangle specified with double values.
Definition: qgsrectangle.h:41
double mapUnitsPerScaleBarUnit() const
Returns the number of map units per scale bar unit used by the scalebar.
Scale bar segment size is calculated to fit a size range.
QBrush brush() const
Returns the primary brush used for filling the scalebar.
QString style() const
Returns the scale bar style name.
void setOpacity(double opacity)
Sets the text&#39;s opacity.
void setLineColor(const QColor &color)
Sets the color used for lines in the scalebar.
void setLineJoinStyle(Qt::PenJoinStyle style)
Sets the join style used when drawing the lines in the scalebar.
double opacity() const
Returns the text&#39;s opacity.
Base class for graphical items within a QgsLayout.
QgsLayoutSize minimumSize() const override
Returns the minimum allowed size of the item, if applicable, or an empty size if item can be freely r...
void readXml(const QDomElement &elem, const QgsReadWriteContext &context)
Read settings from a DOM element.
void setNumericFormat(QgsNumericFormat *format)
Sets the numeric format used for numbers in the scalebar.
QString unitLabel() const
Returns the label for units.
Q_DECL_DEPRECATED QFont font() const
Returns the font used for drawing text in the scalebar.
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...
void refreshDataDefinedProperty(QgsLayoutObject::DataDefinedProperty property=QgsLayoutObject::AllProperties) override
Refreshes a data defined property for the item by reevaluating the property&#39;s value and redrawing the...
This class is a composition of two QSettings instances:
Definition: qgssettings.h:58
QPen pen() const
Returns the pen used for drawing outlines in the scalebar.
LabelVerticalPlacement
Label vertical placement.
double segmentWidth
The width, in millimeters, of each individual segment drawn.
Alignment alignment() const
Returns the scalebar alignment.
void setPen(const QPen &pen)
Sets the pen used for drawing outlines in the scalebar.
Q_DECL_DEPRECATED void setFontColor(const QColor &color)
Sets the color used for drawing text in the scalebar.
QVariant value(const QString &key, const QVariant &defaultValue=QVariant(), Section section=NoSection) const
Returns the value for setting key.
QColor fillColor2() const
Returns the secondary color used for fills in the scalebar.
void setLinkedMap(QgsLayoutItemMap *map)
Sets the map item linked to the scalebar.
A class to represent a 2D point.
Definition: qgspointxy.h:43
void extentChanged()
Emitted when the map&#39;s extent changes.
SegmentSizeMode segmentSizeMode() const
Returns the size mode for the scale bar segments.
void setBoxContentSpace(double space)
Sets the space (margin) between the scalebar box and content in millimeters.
QgsLayoutSize sizeWithUnits() const
Returns the item&#39;s current size, including units.
void setLineCapStyle(Qt::PenCapStyle style)
Sets the cap style used when drawing the lines in the scalebar.
void setLabelVerticalPlacement(LabelVerticalPlacement placement)
Sets the vertical placement of text labels.
void setFont(const QFont &font)
Sets the font used for rendering text.
double lineWidth() const
Returns the line width in millimeters for lines in the scalebar.
void writeXml(QDomElement &element, QDomDocument &document, const QgsReadWriteContext &context) const
Writes the format to an XML element.
#define Q_NOWARN_DEPRECATED_PUSH
Definition: qgis.h:731
static double calculatePrettySize(double minimumSize, double maximumSize)
Calculates a "pretty" size which falls between the range [minimumSize, maximumSize].
QColor color() const
Returns the color that text will be rendered in.
Alignment
Scalebar alignment.
static QIcon getThemeIcon(const QString &name)
Helper to get a theme icon.
void update()
Adjusts the scale bar box size and updates the item.
static QgsNumericFormatRegistry * numericFormatRegistry()
Gets the registry of available numeric formats.
void setAlignment(QgsScaleBarSettings::Alignment alignment)
Sets the scalebar alignment.
bool setEllipsoid(const QString &ellipsoid)
Sets the ellipsoid by its acronym.
QColor lineColor() const
Returns the color used for lines in the scalebar.
Item can only be placed on layers with other items of the same type, but multiple items of this type ...
static Q_INVOKABLE QgsUnitTypes::DistanceUnit decodeDistanceUnit(const QString &string, bool *ok=nullptr)
Decodes a distance unit from a string.
const QgsCoordinateReferenceSystem & crs
An interface for classes which can visit style entity (e.g.
const QgsNumericFormat * numericFormat() const
Returns the numeric format used for numbers in the scalebar.
void setSegmentSizeMode(QgsScaleBarSettings::SegmentSizeMode mode)
Sets the size mode for scale bar segments.
void setStyle(const QString &name)
Sets the scale bar style by name.
virtual void refreshDataDefinedProperty(QgsLayoutObject::DataDefinedProperty property=QgsLayoutObject::AllProperties)
Refreshes a data defined property for the item by reevaluating the property&#39;s value and redrawing the...
static Qt::PenJoinStyle decodePenJoinStyle(const QString &str)
LabelHorizontalPlacement
Label horizontal placement.
virtual bool visit(const QgsStyleEntityVisitorInterface::StyleLeaf &entity)
Called when the visitor will visit a style entity.
QColor fillColor() const
Returns the color used for fills in the scalebar.
int type() const override
A numeric formatter allows for formatting a numeric value for display, using a variety of different f...
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
void refreshItemSize()
Refreshes an item&#39;s size by rechecking it against any possible item fixed or minimum sizes...
double height() const
Returns the scalebar height (in millimeters).
void setMaximumBarWidth(double maxWidth)
Sets the maximum width (in millimeters) for scale bar segments.
bool accept(QgsStyleEntityVisitorInterface *visitor) const override
Accepts the specified style entity visitor, causing it to visit all style entities associated with th...
LabelVerticalPlacement labelVerticalPlacement() const
Returns the vertical placement of text labels.
void setFillColor(const QColor &color)
Sets the color used for fills in the scalebar.
QgsRectangle extent() const
Returns the current map extent.
Layout graphical items for displaying a map.
static Q_INVOKABLE QString toAbbreviatedString(QgsUnitTypes::DistanceUnit unit)
Returns a translated abbreviation representing a distance unit.
int numberOfSegments() const
Returns the number of segments included in the scalebar.
void setSize(double size)
Sets the size for rendered text.
Scalebar secondary fill color.
QgsPropertyCollection mDataDefinedProperties
const QgsLayout * layout() const
Returns the layout the object is attached to.
void setNumberOfSegments(int segments)
Sets the number of segments included in the scalebar.
double minimumBarWidth() const
Returns the minimum width (in millimeters) for scale bar segments.
void setLineCapStyle(Qt::PenCapStyle style)
Sets the cap style used when drawing the lines in the scalebar.
void resizeToMinimumWidth()
Resizes the scale bar to its minimum width, without changing the height.
This class provides a method of storing measurements for use in QGIS layouts using a variety of diffe...
void setMapUnitsPerScaleBarUnit(double units)
Sets the number of map units per scale bar unit used by the scalebar.
QSizeF size
Destination size for scalebar.
QDomElement writeXml(QDomDocument &doc, const QgsReadWriteContext &context) const
Write settings into a DOM element.
void setAlignment(Alignment alignment)
Sets the scalebar alignment.
QgsUnitTypes::DistanceUnit units() const
Returns the distance units used by the scalebar.
double width() const
Returns the width of the rectangle.
Definition: qgsrectangle.h:202
void finalizeRestoreFromXml() override
Called after all pending items have been restored from XML.
Expression contexts are used to encapsulate the parameters around which a QgsExpression should be eva...
QgsRenderContext & renderContext()
Returns a reference to the context&#39;s render context.
Definition: qgslayoutitem.h:72
double boxContentSpace() const
Returns the spacing (margin) between the scalebar box and content in millimeters. ...
void setMinimumBarWidth(double minWidth)
Sets the minimum width (in millimeters) for scale bar segments.
double labelBarSpace() const
Returns the spacing (in millimeters) between labels and the scalebar.
QPointer< QgsLayout > mLayout
virtual void attemptResize(const QgsLayoutSize &size, bool includesFrame=false)
Attempts to resize the item to a specified target size.
void setColor(const QColor &color)
Sets the color that text will be rendered in.
void setMaximumBarWidth(double width)
Sets the maximum width (in millimeters) for scale bar segments.
Degrees, for planar geographic CRS distance measurements.
Definition: qgsunittypes.h:74
void setBoxContentSpace(double space)
Sets the space (margin) between the scalebar box and content in millimeters.
void setSizeUnit(QgsUnitTypes::RenderUnit unit)
Sets the units for the size of rendered text.
void setUnitsPerSegment(double units)
Sets the number of scalebar units per segment.
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.
void setNumericFormat(QgsNumericFormat *format)
Sets the numeric format used for numbers in the scalebar.
void setSegmentSizeMode(SegmentSizeMode mode)
Sets the size mode for scale bar segments.
QgsUnitTypes::LayoutUnit units() const
Returns the units for the size.
static Qt::PenCapStyle decodePenCapStyle(const QString &str)
double unitsPerSegment() const
Returns the number of scalebar units per segment.
void setFillColor2(const QColor &color)
Sets the secondary color used for fills in the scalebar.
void setUnitLabel(const QString &label)
Sets the label for units.
A text format entity for QgsStyle databases.
Definition: qgsstyle.h:1034
SegmentSizeMode
Modes for setting size for scale bar segments.
Base class for layouts, which can contain items such as maps, labels, scalebars, etc.
Definition: qgslayout.h:49
Scale bar segment size is fixed to a map unit.
QIcon icon() const override
Returns the item&#39;s icon.
LabelHorizontalPlacement labelHorizontalPlacement() const
Returns the horizontal placement of text labels.
double maximumBarWidth() const
Returns the maximum width (in millimeters) for scale bar segments.
bool readPropertiesFromElement(const QDomElement &element, const QDomDocument &document, const QgsReadWriteContext &context) override
Sets item state from a DOM element.
void setLabelHorizontalPlacement(QgsScaleBarSettings::LabelHorizontalPlacement placement)
Sets the horizontal placement of text labels.
static Q_INVOKABLE QString encodeUnit(QgsUnitTypes::DistanceUnit unit)
Encodes a distance unit to a string.
void setBackgroundEnabled(bool drawBackground)
Sets whether this item has a background drawn under it or not.
QgsTextFormat & textFormat()
Returns the text format used for drawing text in the scalebar.
Q_DECL_DEPRECATED void setFont(const QFont &font)
Sets the font used for drawing text in the scalebar.
double yMinimum() const
Returns the y minimum value (bottom side of rectangle).
Definition: qgsrectangle.h:177
Contains settings and helpers relating to a render of a QgsLayoutItem.
Definition: qgslayoutitem.h:44
DistanceUnit
Units of distance.
Definition: qgsunittypes.h:66
double xMaximum() const
Returns the x maximum value (right side of rectangle).
Definition: qgsrectangle.h:162
virtual QString displayName() const
Gets item display name.
void setHeight(double height)
Sets the scalebar height (in millimeters).
void setTextFormat(const QgsTextFormat &format)
Sets the text format used for drawing text in the scalebar.
#define Q_NOWARN_DEPRECATED_POP
Definition: qgis.h:732
Unknown distance unit.
Definition: qgsunittypes.h:77
A general purpose distance and area calculator, capable of performing ellipsoid based calculations...
ExportLayerBehavior
Behavior of item when exporting to layered outputs.
QgsLayoutItemScaleBar(QgsLayout *layout)
Constructor for QgsLayoutItemScaleBar, with the specified parent layout.
void draw(QgsLayoutItemRenderContext &context) override
Draws the item&#39;s contents using the specified item render context.
Points (e.g., for font sizes)
Definition: qgsunittypes.h:151
QgsCoordinateReferenceSystem crs() const
Returns coordinate reference system used for rendering the map.
void setUnits(QgsUnitTypes::DistanceUnit units)
Sets the distance units used by the scalebar.
void setLineJoinStyle(Qt::PenJoinStyle style)
Sets the join style used when drawing the lines in the scalebar.
double scale() const
Returns the map scale.
void setLineWidth(double width)
Sets the line width in millimeters for lines in the scalebar.
virtual QString uuid() const
Returns the item identification string.
This class represents a coordinate reference system (CRS).
void setLabelBarSpace(double space)
Sets the spacing (in millimeters) between labels and the scalebar.
bool writePropertiesToElement(QDomElement &element, QDomDocument &document, const QgsReadWriteContext &context) const override
Stores item state within an XML DOM element.
const QgsNumericFormat * numericFormat() const
Returns the numeric format used for numbers in the scalebar.
void applyDefaultSettings()
Applies the default scalebar settings to the scale bar.
void setLabelHorizontalPlacement(LabelHorizontalPlacement placement)
Sets the horizontal placement of text labels.
void setBrush2(const QBrush &brush)
Sets the secondary brush used for filling the scalebar.
double xMinimum() const
Returns the x minimum value (left side of rectangle).
Definition: qgsrectangle.h:167
A layout item subclass for scale bars.
void setNumberOfSegmentsLeft(int segments)
Sets the number of segments included in the left part of the scalebar.
double unitsPerSegment() const
Returns the number of scalebar units per segment.
Q_DECL_DEPRECATED QColor fontColor() const
Returns the color used for drawing text in the scalebar.
Qt::PenCapStyle lineCapStyle() const
Returns the cap style used for drawing lines in the scalebar.
void setSourceCrs(const QgsCoordinateReferenceSystem &crs, const QgsCoordinateTransformContext &context)
Sets source spatial reference system crs.
void setNumberOfSegmentsLeft(int segments)
Sets the number of segments included in the left part of the scalebar.
QBrush brush2() const
Returns the secondary brush for the scalebar.
void setTextFormat(const QgsTextFormat &format)
Sets the text format used for drawing text in the scalebar.
static QString encodePenCapStyle(Qt::PenCapStyle style)
Terrestrial miles.
Definition: qgsunittypes.h:73
Container for all settings relating to text rendering.
This class provides a method of storing sizes, consisting of a width and height, for use in QGIS layo...
Definition: qgslayoutsize.h:40
Qt::PenJoinStyle lineJoinStyle() const
Returns the join style used for drawing lines in the scalebar.
static Q_INVOKABLE double fromUnitToUnitFactor(QgsUnitTypes::DistanceUnit fromUnit, QgsUnitTypes::DistanceUnit toUnit)
Returns the conversion factor between the specified distance units.
QgsTextFormat textFormat() const
Returns the text format used for drawing text in the scalebar.
void setLabelVerticalPlacement(QgsScaleBarSettings::LabelVerticalPlacement placement)
Sets the vertical placement of text labels.
int numberOfSegmentsLeft() const
Returns the number of segments included in the left part of the scalebar.
void setUnits(QgsUnitTypes::DistanceUnit units)
Sets the distance units used by the scalebar.
void changed()
Emitted when the object&#39;s properties change.
DataDefinedProperty
Data defined properties for different item types.
void setUnitsPerSegment(double units)
Sets the number of scalebar units per segment.
void setBrush(const QBrush &brush)
Sets the primary brush used for filling the scalebar.
QFont font() const
Returns the font used for rendering text.
Q_DECL_DEPRECATED void setFont(const QFont &font)
Sets the font used for drawing text in the scalebar.
void setUnitLabel(const QString &label)
Sets the label for units.
double measureLine(const QVector< QgsPointXY > &points) const
Measures the length of a line with multiple segments.
Contains information relating to the style entity currently being visited.
static QString encodePenJoinStyle(Qt::PenJoinStyle style)
void applyDefaultSize(QgsUnitTypes::DistanceUnit units=QgsUnitTypes::DistanceMeters)
Applies the default size to the scale bar (scale bar 1/5 of map item width)
void setWidth(const double width)
Sets the width for the size.
Definition: qgslayoutsize.h:83
void setNumberOfSegments(int segments)
Sets the number of segments included in the scalebar.
static QgsLayoutItemScaleBar * create(QgsLayout *layout)
Returns a new scale bar item for the specified layout.
QgsUnitTypes::DistanceUnit units() const
Returns the distance units used by the scalebar.
All properties for item.
ExportLayerBehavior exportLayerBehavior() const override
Returns the behavior of this item during exporting to layered exports (e.g.
Contains parameters regarding scalebar calculations.