QGIS API Documentation 3.40.0-Bratislava (b56115d8743)
Loading...
Searching...
No Matches
qgslabelinggui.cpp
Go to the documentation of this file.
1/***************************************************************************
2 qgslabelinggui.cpp
3 Smart labeling for vector layers
4 -------------------
5 begin : June 2009
6 copyright : (C) Martin Dobias
7 email : wonder dot sk at gmail dot com
8
9 ***************************************************************************
10 * *
11 * This program is free software; you can redistribute it and/or modify *
12 * it under the terms of the GNU General Public License as published by *
13 * the Free Software Foundation; either version 2 of the License, or *
14 * (at your option) any later version. *
15 * *
16 ***************************************************************************/
17
18#include "qgslabelinggui.h"
19#include "qgsvectorlayer.h"
20#include "qgsmapcanvas.h"
21#include "qgsproject.h"
24#include "qgshelp.h"
25#include "qgsstylesavedialog.h"
26#include "qgscallout.h"
27#include "qgsapplication.h"
28#include "qgscalloutsregistry.h"
33#include "qgsgui.h"
34
35#include <QButtonGroup>
36#include <QMessageBox>
37
39
40QgsExpressionContext QgsLabelingGui::createExpressionContext() const
41{
42 QgsExpressionContext expContext;
43 if ( mCanvas )
44 {
45 expContext = mCanvas->createExpressionContext();
46 }
47 else
48 {
52 }
53
54 if ( mLayer )
55 expContext << QgsExpressionContextUtils::layerScope( mLayer );
56
57 if ( mLayer && mLayer->type() == Qgis::LayerType::Mesh )
58 {
59 if ( mGeomType == Qgis::GeometryType::Point )
61 else if ( mGeomType == Qgis::GeometryType::Polygon )
63 }
64
66
67 //TODO - show actual value
68 expContext.setOriginalValueVariable( QVariant() );
70
71 return expContext;
72}
73
74void QgsLabelingGui::updateCalloutWidget( QgsCallout *callout )
75{
76 if ( !callout )
77 {
78 mCalloutStackedWidget->setCurrentWidget( pageDummy );
79 return;
80 }
81
82 QgsVectorLayer *vLayer = qobject_cast< QgsVectorLayer * >( mLayer );
83 if ( !vLayer )
84 {
85 mCalloutStackedWidget->setCurrentWidget( pageDummy );
86 return;
87 }
88
89 if ( mCalloutStackedWidget->currentWidget() != pageDummy )
90 {
91 // stop updating from the original widget
92 if ( QgsCalloutWidget *pew = qobject_cast< QgsCalloutWidget * >( mCalloutStackedWidget->currentWidget() ) )
93 disconnect( pew, &QgsCalloutWidget::changed, this, &QgsLabelingGui::updatePreview );
94 }
95
97 if ( QgsCalloutAbstractMetadata *am = registry->calloutMetadata( callout->type() ) )
98 {
99 if ( QgsCalloutWidget *w = am->createCalloutWidget( vLayer ) )
100 {
101
102 Qgis::GeometryType geometryType = mGeomType;
103 if ( mGeometryGeneratorGroupBox->isChecked() )
104 geometryType = mGeometryGeneratorType->currentData().value<Qgis::GeometryType>();
105 else if ( vLayer )
106 geometryType = vLayer->geometryType();
107 w->setGeometryType( geometryType );
108 w->setCallout( callout );
109
110 w->setContext( context() );
111 mCalloutStackedWidget->addWidget( w );
112 mCalloutStackedWidget->setCurrentWidget( w );
113 // start receiving updates from widget
114 connect( w, &QgsCalloutWidget::changed, this, &QgsLabelingGui::updatePreview );
115 return;
116 }
117 }
118 // When anything is not right
119 mCalloutStackedWidget->setCurrentWidget( pageDummy );
120}
121
122void QgsLabelingGui::showObstacleSettings()
123{
124 QgsVectorLayer *vLayer = qobject_cast< QgsVectorLayer * >( mLayer );
125 if ( !vLayer )
126 {
127 return;
128 }
129
130 QgsExpressionContext context = createExpressionContext();
131
132 QgsSymbolWidgetContext symbolContext;
133 symbolContext.setExpressionContext( &context );
134 symbolContext.setMapCanvas( mMapCanvas );
135
136 QgsLabelObstacleSettingsWidget *widget = new QgsLabelObstacleSettingsWidget( nullptr, vLayer );
137 widget->setDataDefinedProperties( mDataDefinedProperties );
138 widget->setSettings( mObstacleSettings );
139 widget->setGeometryType( vLayer ? vLayer->geometryType() : Qgis::GeometryType::Unknown );
140 widget->setContext( symbolContext );
141
142 auto applySettings = [ = ]
143 {
144 mObstacleSettings = widget->settings();
145 const QgsPropertyCollection obstacleDataDefinedProperties = widget->dataDefinedProperties();
146 widget->updateDataDefinedProperties( mDataDefinedProperties );
147 emit widgetChanged();
148 };
149
151 if ( panel && panel->dockMode() )
152 {
153 connect( widget, &QgsLabelSettingsWidgetBase::changed, this, [ = ]
154 {
155 applySettings();
156 } );
157 panel->openPanel( widget );
158 }
159 else
160 {
161 QgsLabelSettingsWidgetDialog dialog( widget, this );
162
163 dialog.buttonBox()->addButton( QDialogButtonBox::Help );
164 connect( dialog.buttonBox(), &QDialogButtonBox::helpRequested, this, [ = ]
165 {
166 QgsHelp::openHelp( QStringLiteral( "style_library/label_settings.html#obstacles" ) );
167 } );
168
169 if ( dialog.exec() )
170 {
171 applySettings();
172 }
173 // reactivate button's window
174 activateWindow();
175 }
176}
177
178void QgsLabelingGui::showLineAnchorSettings()
179{
180 QgsVectorLayer *vLayer = qobject_cast< QgsVectorLayer * >( mLayer );
181 if ( !vLayer )
182 {
183 return;
184 }
185
186 QgsExpressionContext context = createExpressionContext();
187
188 QgsSymbolWidgetContext symbolContext;
189 symbolContext.setExpressionContext( &context );
190 symbolContext.setMapCanvas( mMapCanvas );
191
192 QgsLabelLineAnchorWidget *widget = new QgsLabelLineAnchorWidget( nullptr, vLayer );
193 widget->setDataDefinedProperties( mDataDefinedProperties );
194 widget->setSettings( mLineSettings );
195 widget->setGeometryType( vLayer ? vLayer->geometryType() : Qgis::GeometryType::Unknown );
196 widget->setContext( symbolContext );
197
198 auto applySettings = [ = ]
199 {
200 const QgsLabelLineSettings widgetSettings = widget->settings();
201 mLineSettings.setLineAnchorPercent( widgetSettings.lineAnchorPercent() );
202 mLineSettings.setAnchorType( widgetSettings.anchorType() );
203 mLineSettings.setAnchorClipping( widgetSettings.anchorClipping() );
204 mLineSettings.setAnchorTextPoint( widgetSettings.anchorTextPoint() );
205 const QgsPropertyCollection obstacleDataDefinedProperties = widget->dataDefinedProperties();
206 widget->updateDataDefinedProperties( mDataDefinedProperties );
207 emit widgetChanged();
208 };
209
211 if ( panel && panel->dockMode() )
212 {
213 connect( widget, &QgsLabelSettingsWidgetBase::changed, this, [ = ]
214 {
215 applySettings();
216 } );
217 panel->openPanel( widget );
218 }
219 else
220 {
221 QgsLabelSettingsWidgetDialog dialog( widget, this );
222
223 dialog.buttonBox()->addButton( QDialogButtonBox::Help );
224 connect( dialog.buttonBox(), &QDialogButtonBox::helpRequested, this, [ = ]
225 {
226 QgsHelp::openHelp( QStringLiteral( "style_library/label_settings.html#placement-for-line-layers" ) );
227 } );
228
229 if ( dialog.exec() )
230 {
231 applySettings();
232 }
233 // reactivate button's window
234 activateWindow();
235 }
236}
237
238QgsLabelingGui::QgsLabelingGui( QgsMapLayer *layer, QgsMapCanvas *mapCanvas, const QgsPalLayerSettings &layerSettings, QWidget *parent, Qgis::GeometryType geomType )
239 : QgsTextFormatWidget( mapCanvas, parent, QgsTextFormatWidget::Labeling, layer )
240 , mSettings( layerSettings )
241 , mMode( NoLabels )
242 , mCanvas( mapCanvas )
243{
245
246 mGeomType = geomType;
247
248 mFontMultiLineAlignComboBox->addItem( tr( "Left" ), static_cast< int >( Qgis::LabelMultiLineAlignment::Left ) );
249 mFontMultiLineAlignComboBox->addItem( tr( "Center" ), static_cast< int >( Qgis::LabelMultiLineAlignment::Center ) );
250 mFontMultiLineAlignComboBox->addItem( tr( "Right" ), static_cast< int >( Qgis::LabelMultiLineAlignment::Right ) );
251 mFontMultiLineAlignComboBox->addItem( tr( "Justify" ), static_cast< int >( Qgis::LabelMultiLineAlignment::Justify ) );
252
253 mCoordRotationUnitComboBox->addItem( QgsUnitTypes::toString( Qgis::AngleUnit::Degrees ), static_cast< int >( Qgis::AngleUnit::Degrees ) );
254 mCoordRotationUnitComboBox->addItem( QgsUnitTypes::toString( Qgis::AngleUnit::Radians ), static_cast< int >( Qgis::AngleUnit::Radians ) );
255 mCoordRotationUnitComboBox->addItem( QgsUnitTypes::toString( Qgis::AngleUnit::Gon ), static_cast< int >( Qgis::AngleUnit::Gon ) );
256 mCoordRotationUnitComboBox->addItem( QgsUnitTypes::toString( Qgis::AngleUnit::MinutesOfArc ), static_cast< int >( Qgis::AngleUnit::MinutesOfArc ) );
257 mCoordRotationUnitComboBox->addItem( QgsUnitTypes::toString( Qgis::AngleUnit::SecondsOfArc ), static_cast< int >( Qgis::AngleUnit::SecondsOfArc ) );
258 mCoordRotationUnitComboBox->addItem( QgsUnitTypes::toString( Qgis::AngleUnit::Turn ), static_cast< int >( Qgis::AngleUnit::Turn ) );
259 mCoordRotationUnitComboBox->addItem( QgsUnitTypes::toString( Qgis::AngleUnit::MilliradiansSI ), static_cast< int >( Qgis::AngleUnit::MilliradiansSI ) );
260 mCoordRotationUnitComboBox->addItem( QgsUnitTypes::toString( Qgis::AngleUnit::MilNATO ), static_cast< int >( Qgis::AngleUnit::MilNATO ) );
261
262 // connections for groupboxes with separate activation checkboxes (that need to honor data defined setting)
263 connect( mBufferDrawChkBx, &QAbstractButton::toggled, this, &QgsLabelingGui::updateUi );
264 connect( mBufferDrawDDBtn, &QgsPropertyOverrideButton::changed, this, &QgsLabelingGui::updateUi );
265 connect( mEnableMaskChkBx, &QAbstractButton::toggled, this, &QgsLabelingGui::updateUi );
266 connect( mShapeDrawChkBx, &QAbstractButton::toggled, this, &QgsLabelingGui::updateUi );
267 connect( mCalloutsDrawCheckBox, &QAbstractButton::toggled, this, &QgsLabelingGui::updateUi );
268 connect( mShadowDrawChkBx, &QAbstractButton::toggled, this, &QgsLabelingGui::updateUi );
269 connect( mDirectSymbChkBx, &QAbstractButton::toggled, this, &QgsLabelingGui::updateUi );
270 connect( mFormatNumChkBx, &QAbstractButton::toggled, this, &QgsLabelingGui::updateUi );
271 connect( mScaleBasedVisibilityChkBx, &QAbstractButton::toggled, this, &QgsLabelingGui::updateUi );
272 connect( mFontLimitPixelChkBox, &QAbstractButton::toggled, this, &QgsLabelingGui::updateUi );
273 connect( mGeometryGeneratorGroupBox, &QGroupBox::toggled, this, &QgsLabelingGui::updateGeometryTypeBasedWidgets );
274 connect( mGeometryGeneratorType, qOverload<int>( &QComboBox::currentIndexChanged ), this, &QgsLabelingGui::updateGeometryTypeBasedWidgets );
275 connect( mGeometryGeneratorExpressionButton, &QToolButton::clicked, this, &QgsLabelingGui::showGeometryGeneratorExpressionBuilder );
276 connect( mGeometryGeneratorGroupBox, &QGroupBox::toggled, this, &QgsLabelingGui::validateGeometryGeneratorExpression );
277 connect( mGeometryGenerator, &QgsCodeEditorExpression::textChanged, this, &QgsLabelingGui::validateGeometryGeneratorExpression );
278 connect( mGeometryGeneratorType, qOverload<int>( &QComboBox::currentIndexChanged ), this, &QgsLabelingGui::validateGeometryGeneratorExpression );
279 connect( mObstacleSettingsButton, &QAbstractButton::clicked, this, &QgsLabelingGui::showObstacleSettings );
280 connect( mLineAnchorSettingsButton, &QAbstractButton::clicked, this, &QgsLabelingGui::showLineAnchorSettings );
281
282 mFieldExpressionWidget->registerExpressionContextGenerator( this );
283
284 mMinScaleWidget->setMapCanvas( mCanvas );
285 mMinScaleWidget->setShowCurrentScaleButton( true );
286 mMaxScaleWidget->setMapCanvas( mCanvas );
287 mMaxScaleWidget->setShowCurrentScaleButton( true );
288
289 mGeometryGeneratorExpressionButton->setSizePolicy( QSizePolicy::Minimum, QSizePolicy::Minimum );
290 mGeometryGeneratorExpressionButton->setIcon( QgsApplication::getThemeIcon( QStringLiteral( "/mIconExpression.svg" ) ) );
291
292 const QStringList calloutTypes = QgsApplication::calloutRegistry()->calloutTypes();
293 for ( const QString &type : calloutTypes )
294 {
295 mCalloutStyleComboBox->addItem( QgsApplication::calloutRegistry()->calloutMetadata( type )->icon(),
296 QgsApplication::calloutRegistry()->calloutMetadata( type )->visibleName(), type );
297 }
298
299 mGeometryGeneratorWarningLabel->setStyleSheet( QStringLiteral( "color: #FFC107;" ) );
300 mGeometryGeneratorWarningLabel->setTextInteractionFlags( Qt::TextBrowserInteraction );
301 connect( mGeometryGeneratorWarningLabel, &QLabel::linkActivated, this, [this]( const QString & link )
302 {
303 if ( link == QLatin1String( "#determineGeometryGeneratorType" ) )
304 determineGeometryGeneratorType();
305 } );
306
307 connect( mCalloutStyleComboBox, static_cast<void ( QComboBox::* )( int )>( &QComboBox::currentIndexChanged ), this, &QgsLabelingGui::calloutTypeChanged );
308
309 mLblNoObstacle1->installEventFilter( this );
310
311 setLayer( layer );
312}
313
314void QgsLabelingGui::setLayer( QgsMapLayer *mapLayer )
315{
316 mPreviewFeature = QgsFeature();
317
318 if ( ( !mapLayer || mapLayer->type() != Qgis::LayerType::Vector ) && mGeomType == Qgis::GeometryType::Unknown )
319 {
320 setEnabled( false );
321 return;
322 }
323
324 setEnabled( true );
325
326 mLayer = mapLayer;
327 QgsVectorLayer *vLayer = qobject_cast<QgsVectorLayer *>( mapLayer );
328
329 mTextFormatsListWidget->setLayerType( vLayer ? vLayer->geometryType() : mGeomType );
330 mBackgroundMarkerSymbolButton->setLayer( vLayer );
331 mBackgroundFillSymbolButton->setLayer( vLayer );
332
333 // load labeling settings from layer
334 updateGeometryTypeBasedWidgets();
335
336 mFieldExpressionWidget->setLayer( mapLayer );
338 if ( mLayer )
339 da.setSourceCrs( mLayer->crs(), QgsProject::instance()->transformContext() );
340 da.setEllipsoid( QgsProject::instance()->ellipsoid() );
341 mFieldExpressionWidget->setGeomCalculator( da );
342
343 mFieldExpressionWidget->setEnabled( mMode == Labels || !mLayer );
344 mLabelingFrame->setEnabled( mMode == Labels || !mLayer );
345
346 blockInitSignals( true );
347
348 mGeometryGenerator->setText( mSettings.geometryGenerator );
349 mGeometryGeneratorGroupBox->setChecked( mSettings.geometryGeneratorEnabled );
350 if ( !mSettings.geometryGeneratorEnabled )
351 mGeometryGeneratorGroupBox->setCollapsed( true );
352 mGeometryGeneratorType->setCurrentIndex( mGeometryGeneratorType->findData( QVariant::fromValue( mSettings.geometryGeneratorType ) ) );
353
354 updateWidgetForFormat( mSettings.format().isValid() ? mSettings.format() : QgsStyle::defaultTextFormatForProject( QgsProject::instance(), QgsStyle::TextFormatContext::Labeling ) );
355
356 mFieldExpressionWidget->setRow( -1 );
357 mFieldExpressionWidget->setField( mSettings.fieldName );
358 mCheckBoxSubstituteText->setChecked( mSettings.useSubstitutions );
359 mSubstitutions = mSettings.substitutions;
360
361 // populate placement options
362 mCentroidRadioWhole->setChecked( mSettings.centroidWhole );
363 mCentroidInsideCheckBox->setChecked( mSettings.centroidInside );
364 mFitInsidePolygonCheckBox->setChecked( mSettings.fitInPolygonOnly );
365 mLineDistanceSpnBx->setValue( mSettings.dist );
366 mLineDistanceUnitWidget->setUnit( mSettings.distUnits );
367 mLineDistanceUnitWidget->setMapUnitScale( mSettings.distMapUnitScale );
368
369 mMaximumDistanceSpnBx->setValue( mSettings.pointSettings().maximumDistance() );
370 mMaximumDistanceUnitWidget->setUnit( mSettings.pointSettings().maximumDistanceUnit() );
371 mMaximumDistanceUnitWidget->setMapUnitScale( mSettings.pointSettings().maximumDistanceMapUnitScale() );
372
373 mOffsetTypeComboBox->setCurrentIndex( mOffsetTypeComboBox->findData( static_cast< int >( mSettings.offsetType ) ) );
374 mQuadrantBtnGrp->button( static_cast<int>( mSettings.pointSettings().quadrant() ) )->setChecked( true );
375 mPointOffsetXSpinBox->setValue( mSettings.xOffset );
376 mPointOffsetYSpinBox->setValue( mSettings.yOffset );
377 mPointOffsetUnitWidget->setUnit( mSettings.offsetUnits );
378 mPointOffsetUnitWidget->setMapUnitScale( mSettings.labelOffsetMapUnitScale );
379 mPointAngleSpinBox->setValue( mSettings.angleOffset );
380 chkLineAbove->setChecked( mSettings.lineSettings().placementFlags() & Qgis::LabelLinePlacementFlag::AboveLine );
381 chkLineBelow->setChecked( mSettings.lineSettings().placementFlags() & Qgis::LabelLinePlacementFlag::BelowLine );
382 chkLineOn->setChecked( mSettings.lineSettings().placementFlags() & Qgis::LabelLinePlacementFlag::OnLine );
383 chkLineOrientationDependent->setChecked( !( mSettings.lineSettings().placementFlags() & Qgis::LabelLinePlacementFlag::MapOrientation ) );
384
385 mCheckAllowLabelsOutsidePolygons->setChecked( mSettings.polygonPlacementFlags() & Qgis::LabelPolygonPlacementFlag::AllowPlacementOutsideOfPolygon );
386
387 const int placementIndex = mPlacementModeComboBox->findData( static_cast< int >( mSettings.placement ) );
388 if ( placementIndex >= 0 )
389 {
390 mPlacementModeComboBox->setCurrentIndex( placementIndex );
391 }
392 else
393 {
394 // use default placement for layer type
395 mPlacementModeComboBox->setCurrentIndex( 0 );
396 }
397
398 // Label repeat distance
399 mRepeatDistanceSpinBox->setValue( mSettings.repeatDistance );
400 mRepeatDistanceUnitWidget->setUnit( mSettings.repeatDistanceUnit );
401 mRepeatDistanceUnitWidget->setMapUnitScale( mSettings.repeatDistanceMapUnitScale );
402
403 mOverrunDistanceSpinBox->setValue( mSettings.lineSettings().overrunDistance() );
404 mOverrunDistanceUnitWidget->setUnit( mSettings.lineSettings().overrunDistanceUnit() );
405 mOverrunDistanceUnitWidget->setMapUnitScale( mSettings.lineSettings().overrunDistanceMapUnitScale() );
406
407 mPrioritySlider->setValue( mSettings.priority );
408 mChkNoObstacle->setChecked( mSettings.obstacleSettings().isObstacle() );
409
410 mObstacleSettings = mSettings.obstacleSettings();
411 mLineSettings = mSettings.lineSettings();
412
413 chkLabelPerFeaturePart->setChecked( mSettings.labelPerPart );
414
415 mComboOverlapHandling->setCurrentIndex( mComboOverlapHandling->findData( static_cast< int >( mSettings.placementSettings().overlapHandling() ) ) );
416 mCheckAllowDegradedPlacement->setChecked( mSettings.placementSettings().allowDegradedPlacement() );
417 mPrioritizationComboBox->setCurrentIndex( mPrioritizationComboBox->findData( QVariant::fromValue( mSettings.placementSettings().prioritization() ) ) );
418
419 chkMergeLines->setChecked( mSettings.lineSettings().mergeLines() );
420 mMinSizeSpinBox->setValue( mSettings.thinningSettings().minimumFeatureSize() );
421 mLimitLabelChkBox->setChecked( mSettings.thinningSettings().limitNumberOfLabelsEnabled() );
422 mLimitLabelSpinBox->setValue( mSettings.thinningSettings().maximumNumberLabels() );
423
424 // direction symbol(s)
425 mDirectSymbChkBx->setChecked( mSettings.lineSettings().addDirectionSymbol() );
426 mDirectSymbLeftLineEdit->setText( mSettings.lineSettings().leftDirectionSymbol() );
427 mDirectSymbRightLineEdit->setText( mSettings.lineSettings().rightDirectionSymbol() );
428 mDirectSymbRevChkBx->setChecked( mSettings.lineSettings().reverseDirectionSymbol() );
429
430 mDirectSymbBtnGrp->button( static_cast<int>( mSettings.lineSettings().directionSymbolPlacement() ) )->setChecked( true );
431 mUpsidedownBtnGrp->button( static_cast<int>( mSettings.upsidedownLabels ) )->setChecked( true );
432
433 // curved label max character angles
434 mMaxCharAngleInDSpinBox->setValue( mSettings.maxCurvedCharAngleIn );
435 // lyr.maxCurvedCharAngleOut must be negative, but it is shown as positive spinbox in GUI
436 mMaxCharAngleOutDSpinBox->setValue( std::fabs( mSettings.maxCurvedCharAngleOut ) );
437
438 wrapCharacterEdit->setText( mSettings.wrapChar );
439 mAutoWrapLengthSpinBox->setValue( mSettings.autoWrapLength );
440 mAutoWrapTypeComboBox->setCurrentIndex( mSettings.useMaxLineLengthForAutoWrap ? 0 : 1 );
441
442 if ( mFontMultiLineAlignComboBox->findData( static_cast< int >( mSettings.multilineAlign ) ) != -1 )
443 {
444 mFontMultiLineAlignComboBox->setCurrentIndex( mFontMultiLineAlignComboBox->findData( static_cast< int >( mSettings.multilineAlign ) ) );
445 }
446 else
447 {
448 // the default pal layer settings for multiline alignment is to follow label placement, which isn't always available
449 // revert to left alignment in such case
450 mFontMultiLineAlignComboBox->setCurrentIndex( 0 );
451 }
452
453 chkPreserveRotation->setChecked( mSettings.preserveRotation );
454
455 mCoordRotationUnitComboBox->setCurrentIndex( 0 );
456 if ( mCoordRotationUnitComboBox->findData( static_cast< unsigned int >( mSettings.rotationUnit() ) ) >= 0 )
457 mCoordRotationUnitComboBox->setCurrentIndex( mCoordRotationUnitComboBox->findData( static_cast< unsigned int >( mSettings.rotationUnit() ) ) );
458
459 mScaleBasedVisibilityChkBx->setChecked( mSettings.scaleVisibility );
460 mMinScaleWidget->setScale( mSettings.minimumScale );
461 mMaxScaleWidget->setScale( mSettings.maximumScale );
462
463 mFormatNumChkBx->setChecked( mSettings.formatNumbers );
464 mFormatNumDecimalsSpnBx->setValue( mSettings.decimals );
465 mFormatNumPlusSignChkBx->setChecked( mSettings.plusSign );
466
467 // set pixel size limiting checked state before unit choice so limiting can be
468 // turned on as a default for map units, if minimum trigger value of 0 is used
469 mFontLimitPixelChkBox->setChecked( mSettings.fontLimitPixelSize );
470 mMinPixelLimit = mSettings.fontMinPixelSize; // ignored after first settings save
471 mFontMinPixelSpinBox->setValue( mSettings.fontMinPixelSize == 0 ? 3 : mSettings.fontMinPixelSize );
472 mFontMaxPixelSpinBox->setValue( mSettings.fontMaxPixelSize );
473
474 mZIndexSpinBox->setValue( mSettings.zIndex );
475
476 mDataDefinedProperties = mSettings.dataDefinedProperties();
477
478 // callout settings, to move to custom widget when multiple styles exist
479 if ( auto *lCallout = mSettings.callout() )
480 {
481 whileBlocking( mCalloutsDrawCheckBox )->setChecked( lCallout->enabled() );
482 whileBlocking( mCalloutStyleComboBox )->setCurrentIndex( mCalloutStyleComboBox->findData( lCallout->type() ) );
483 updateCalloutWidget( lCallout );
484 }
485 else
486 {
487 std::unique_ptr< QgsCallout > defaultCallout( QgsCalloutRegistry::defaultCallout() );
488 whileBlocking( mCalloutStyleComboBox )->setCurrentIndex( mCalloutStyleComboBox->findData( defaultCallout->type() ) );
489 whileBlocking( mCalloutsDrawCheckBox )->setChecked( false );
490 updateCalloutWidget( defaultCallout.get() );
491 }
492
493 updatePlacementWidgets();
494 updateLinePlacementOptions();
495
496 // needs to come before data defined setup, so connections work
497 blockInitSignals( false );
498
499 // set up data defined toolbuttons
500 // do this after other widgets are configured, so they can be enabled/disabled
501 populateDataDefinedButtons();
502
503 updateUi(); // should come after data defined button setup
504}
505
506void QgsLabelingGui::setSettings( const QgsPalLayerSettings &settings )
507{
508 mSettings = settings;
509 setLayer( mLayer );
510}
511
512void QgsLabelingGui::blockInitSignals( bool block )
513{
514 chkLineAbove->blockSignals( block );
515 chkLineBelow->blockSignals( block );
516 mPlacementModeComboBox->blockSignals( block );
517}
518
519void QgsLabelingGui::setLabelMode( LabelMode mode )
520{
521 mMode = mode;
522 mFieldExpressionWidget->setEnabled( mMode == Labels );
523 mLabelingFrame->setEnabled( mMode == Labels );
524}
525
526QgsPalLayerSettings QgsLabelingGui::layerSettings()
527{
529
530 // restore properties which aren't exposed in GUI
531 lyr.setUnplacedVisibility( mSettings.unplacedVisibility() );
532
533 lyr.drawLabels = ( mMode == Labels ) || !mLayer;
534
535 bool isExpression;
536 lyr.fieldName = mFieldExpressionWidget->currentField( &isExpression );
537 lyr.isExpression = isExpression;
538
539 lyr.dist = 0;
540
542 if ( mCheckAllowLabelsOutsidePolygons->isChecked() )
544 lyr.setPolygonPlacementFlags( polygonPlacementFlags );
545
546 lyr.centroidWhole = mCentroidRadioWhole->isChecked();
547 lyr.centroidInside = mCentroidInsideCheckBox->isChecked();
548 lyr.fitInPolygonOnly = mFitInsidePolygonCheckBox->isChecked();
549 lyr.dist = mLineDistanceSpnBx->value();
550 lyr.distUnits = mLineDistanceUnitWidget->unit();
551 lyr.distMapUnitScale = mLineDistanceUnitWidget->getMapUnitScale();
552
553 lyr.pointSettings().setMaximumDistance( mMaximumDistanceSpnBx->value() );
554 lyr.pointSettings().setMaximumDistanceUnit( mMaximumDistanceUnitWidget->unit() );
555 lyr.pointSettings().setMaximumDistanceMapUnitScale( mMaximumDistanceUnitWidget->getMapUnitScale() );
556
557 lyr.offsetType = static_cast< Qgis::LabelOffsetType >( mOffsetTypeComboBox->currentData().toInt() );
558 if ( mQuadrantBtnGrp )
559 {
560 lyr.pointSettings().setQuadrant( static_cast< Qgis::LabelQuadrantPosition >( mQuadrantBtnGrp->checkedId() ) );
561 }
562 lyr.xOffset = mPointOffsetXSpinBox->value();
563 lyr.yOffset = mPointOffsetYSpinBox->value();
564 lyr.offsetUnits = mPointOffsetUnitWidget->unit();
565 lyr.labelOffsetMapUnitScale = mPointOffsetUnitWidget->getMapUnitScale();
566 lyr.angleOffset = mPointAngleSpinBox->value();
567
569 if ( chkLineAbove->isChecked() )
570 linePlacementFlags |= Qgis::LabelLinePlacementFlag::AboveLine;
571 if ( chkLineBelow->isChecked() )
572 linePlacementFlags |= Qgis::LabelLinePlacementFlag::BelowLine;
573 if ( chkLineOn->isChecked() )
574 linePlacementFlags |= Qgis::LabelLinePlacementFlag::OnLine;
575 if ( ! chkLineOrientationDependent->isChecked() )
577 lyr.lineSettings().setPlacementFlags( linePlacementFlags );
578
579 lyr.placement = static_cast< Qgis::LabelPlacement >( mPlacementModeComboBox->currentData().toInt() );
580
581 lyr.repeatDistance = mRepeatDistanceSpinBox->value();
582 lyr.repeatDistanceUnit = mRepeatDistanceUnitWidget->unit();
583 lyr.repeatDistanceMapUnitScale = mRepeatDistanceUnitWidget->getMapUnitScale();
584
585 lyr.lineSettings().setOverrunDistance( mOverrunDistanceSpinBox->value() );
586 lyr.lineSettings().setOverrunDistanceUnit( mOverrunDistanceUnitWidget->unit() );
587 lyr.lineSettings().setOverrunDistanceMapUnitScale( mOverrunDistanceUnitWidget->getMapUnitScale() );
588
589 lyr.priority = mPrioritySlider->value();
590
591 mObstacleSettings.setIsObstacle( mChkNoObstacle->isChecked() || mMode == ObstaclesOnly );
592 lyr.setObstacleSettings( mObstacleSettings );
593
594 lyr.lineSettings().setLineAnchorPercent( mLineSettings.lineAnchorPercent() );
595 lyr.lineSettings().setAnchorType( mLineSettings.anchorType() );
596 lyr.lineSettings().setAnchorClipping( mLineSettings.anchorClipping() );
597 lyr.lineSettings().setAnchorTextPoint( mLineSettings.anchorTextPoint() );
598
599 lyr.labelPerPart = chkLabelPerFeaturePart->isChecked();
600 lyr.placementSettings().setOverlapHandling( static_cast< Qgis::LabelOverlapHandling>( mComboOverlapHandling->currentData().toInt() ) );
601 lyr.placementSettings().setAllowDegradedPlacement( mCheckAllowDegradedPlacement->isChecked() );
602 lyr.placementSettings().setPrioritization( mPrioritizationComboBox->currentData().value< Qgis::LabelPrioritization >() );
603
604 lyr.lineSettings().setMergeLines( chkMergeLines->isChecked() );
605
606 lyr.scaleVisibility = mScaleBasedVisibilityChkBx->isChecked();
607 lyr.minimumScale = mMinScaleWidget->scale();
608 lyr.maximumScale = mMaxScaleWidget->scale();
609 lyr.useSubstitutions = mCheckBoxSubstituteText->isChecked();
610 lyr.substitutions = mSubstitutions;
611
612 lyr.setFormat( format( false ) );
613
614 // format numbers
615 lyr.formatNumbers = mFormatNumChkBx->isChecked();
616 lyr.decimals = mFormatNumDecimalsSpnBx->value();
617 lyr.plusSign = mFormatNumPlusSignChkBx->isChecked();
618
619 // direction symbol(s)
620 lyr.lineSettings().setAddDirectionSymbol( mDirectSymbChkBx->isChecked() );
621 lyr.lineSettings().setLeftDirectionSymbol( mDirectSymbLeftLineEdit->text() );
622 lyr.lineSettings().setRightDirectionSymbol( mDirectSymbRightLineEdit->text() );
623 lyr.lineSettings().setReverseDirectionSymbol( mDirectSymbRevChkBx->isChecked() );
624 if ( mDirectSymbBtnGrp )
625 {
626 lyr.lineSettings().setDirectionSymbolPlacement( static_cast< QgsLabelLineSettings::DirectionSymbolPlacement >( mDirectSymbBtnGrp->checkedId() ) );
627 }
628 if ( mUpsidedownBtnGrp )
629 {
630 lyr.upsidedownLabels = static_cast< Qgis::UpsideDownLabelHandling >( mUpsidedownBtnGrp->checkedId() );
631 }
632
633 lyr.maxCurvedCharAngleIn = mMaxCharAngleInDSpinBox->value();
634 // lyr.maxCurvedCharAngleOut must be negative, but it is shown as positive spinbox in GUI
635 lyr.maxCurvedCharAngleOut = -mMaxCharAngleOutDSpinBox->value();
636
637
638 lyr.thinningSettings().setMinimumFeatureSize( mMinSizeSpinBox->value() );
639 lyr.thinningSettings().setLimitNumberLabelsEnabled( mLimitLabelChkBox->isChecked() );
640 lyr.thinningSettings().setMaximumNumberLabels( mLimitLabelSpinBox->value() );
641 lyr.fontLimitPixelSize = mFontLimitPixelChkBox->isChecked();
642 lyr.fontMinPixelSize = mFontMinPixelSpinBox->value();
643 lyr.fontMaxPixelSize = mFontMaxPixelSpinBox->value();
644 lyr.wrapChar = wrapCharacterEdit->text();
645 lyr.autoWrapLength = mAutoWrapLengthSpinBox->value();
646 lyr.useMaxLineLengthForAutoWrap = mAutoWrapTypeComboBox->currentIndex() == 0;
647 lyr.multilineAlign = static_cast< Qgis::LabelMultiLineAlignment >( mFontMultiLineAlignComboBox->currentData().toInt() );
648 lyr.preserveRotation = chkPreserveRotation->isChecked();
649 lyr.setRotationUnit( static_cast< Qgis::AngleUnit >( mCoordRotationUnitComboBox->currentData().toInt() ) );
650 lyr.geometryGenerator = mGeometryGenerator->text();
651 lyr.geometryGeneratorType = mGeometryGeneratorType->currentData().value<Qgis::GeometryType>();
652 lyr.geometryGeneratorEnabled = mGeometryGeneratorGroupBox->isChecked();
653
654 QgsVectorLayer *vLayer = qobject_cast< QgsVectorLayer * >( mLayer );
655 lyr.layerType = vLayer ? vLayer->geometryType() : mGeomType;
656
657 lyr.zIndex = mZIndexSpinBox->value();
658
659 lyr.setDataDefinedProperties( mDataDefinedProperties );
660
661 // callout settings
662 const QString calloutType = mCalloutStyleComboBox->currentData().toString();
663 std::unique_ptr< QgsCallout > callout;
664 if ( QgsCalloutWidget *pew = qobject_cast< QgsCalloutWidget * >( mCalloutStackedWidget->currentWidget() ) )
665 {
666 callout.reset( pew->callout()->clone() );
667 }
668 if ( !callout )
669 callout.reset( QgsApplication::calloutRegistry()->createCallout( calloutType ) );
670
671 callout->setEnabled( mCalloutsDrawCheckBox->isChecked() );
672 lyr.setCallout( callout.release() );
673
674 return lyr;
675}
676
677void QgsLabelingGui::syncDefinedCheckboxFrame( QgsPropertyOverrideButton *ddBtn, QCheckBox *chkBx, QFrame *f )
678{
679 f->setEnabled( chkBx->isChecked() || ddBtn->isActive() );
680}
681
682bool QgsLabelingGui::eventFilter( QObject *object, QEvent *event )
683{
684 if ( object == mLblNoObstacle1 )
685 {
686 if ( event->type() == QEvent::MouseButtonPress && qgis::down_cast< QMouseEvent * >( event )->button() == Qt::LeftButton )
687 {
688 // clicking the obstacle label toggles the checkbox, just like a "normal" checkbox label...
689 mChkNoObstacle->setChecked( !mChkNoObstacle->isChecked() );
690 return true;
691 }
692 return false;
693 }
694 return QgsTextFormatWidget::eventFilter( object, event );
695}
696
697void QgsLabelingGui::updateUi()
698{
699 // enable/disable inline groupbox-like setups (that need to honor data defined setting)
700
701 syncDefinedCheckboxFrame( mBufferDrawDDBtn, mBufferDrawChkBx, mBufferFrame );
702 syncDefinedCheckboxFrame( mEnableMaskDDBtn, mEnableMaskChkBx, mMaskFrame );
703 syncDefinedCheckboxFrame( mShapeDrawDDBtn, mShapeDrawChkBx, mShapeFrame );
704 syncDefinedCheckboxFrame( mShadowDrawDDBtn, mShadowDrawChkBx, mShadowFrame );
705 syncDefinedCheckboxFrame( mCalloutDrawDDBtn, mCalloutsDrawCheckBox, mCalloutFrame );
706
707 syncDefinedCheckboxFrame( mDirectSymbDDBtn, mDirectSymbChkBx, mDirectSymbFrame );
708 syncDefinedCheckboxFrame( mFormatNumDDBtn, mFormatNumChkBx, mFormatNumFrame );
709 syncDefinedCheckboxFrame( mScaleBasedVisibilityDDBtn, mScaleBasedVisibilityChkBx, mScaleBasedVisibilityFrame );
710 syncDefinedCheckboxFrame( mFontLimitPixelDDBtn, mFontLimitPixelChkBox, mFontLimitPixelFrame );
711
712 chkMergeLines->setEnabled( !mDirectSymbChkBx->isChecked() );
713 if ( mDirectSymbChkBx->isChecked() )
714 {
715 chkMergeLines->setToolTip( tr( "This option is not compatible with line direction symbols." ) );
716 }
717 else
718 {
719 chkMergeLines->setToolTip( QString() );
720 }
721}
722
723void QgsLabelingGui::setFormatFromStyle( const QString &name, QgsStyle::StyleEntity type, const QString &stylePath )
724{
725 QgsStyle *style = QgsProject::instance()->styleSettings()->styleAtPath( stylePath );
726
727 if ( !style )
728 style = QgsStyle::defaultStyle();
729
730 switch ( type )
731 {
739 {
740 QgsTextFormatWidget::setFormatFromStyle( name, type, stylePath );
741 return;
742 }
743
745 {
746 if ( !style->labelSettingsNames().contains( name ) )
747 return;
748
749 QgsPalLayerSettings settings = style->labelSettings( name );
750 if ( settings.fieldName.isEmpty() )
751 {
752 // if saved settings doesn't have a field name stored, retain the current one
753 bool isExpression;
754 settings.fieldName = mFieldExpressionWidget->currentField( &isExpression );
755 settings.isExpression = isExpression;
756 }
757 setSettings( settings );
758 break;
759 }
760 }
761}
762
763void QgsLabelingGui::setContext( const QgsSymbolWidgetContext &context )
764{
765 if ( QgsCalloutWidget *cw = qobject_cast< QgsCalloutWidget * >( mCalloutStackedWidget->currentWidget() ) )
766 {
767 cw->setContext( context );
768 }
770}
771
772void QgsLabelingGui::saveFormat()
773{
775 saveDlg.setDefaultTags( mTextFormatsListWidget->currentTagFilter() );
776 if ( !saveDlg.exec() )
777 return;
778
779 if ( saveDlg.name().isEmpty() )
780 return;
781
782 QgsStyle *style = saveDlg.destinationStyle();
783 if ( !style )
784 return;
785
786 switch ( saveDlg.selectedType() )
787 {
789 {
790 // check if there is no format with same name
791 if ( style->textFormatNames().contains( saveDlg.name() ) )
792 {
793 const int res = QMessageBox::warning( this, tr( "Save Text Format" ),
794 tr( "Format with name '%1' already exists. Overwrite?" )
795 .arg( saveDlg.name() ),
796 QMessageBox::Yes | QMessageBox::No );
797 if ( res != QMessageBox::Yes )
798 {
799 return;
800 }
801 style->removeTextFormat( saveDlg.name() );
802 }
803 const QStringList symbolTags = saveDlg.tags().split( ',' );
804
805 const QgsTextFormat newFormat = format();
806 style->addTextFormat( saveDlg.name(), newFormat );
807 style->saveTextFormat( saveDlg.name(), newFormat, saveDlg.isFavorite(), symbolTags );
808 break;
809 }
810
812 {
813 // check if there is no settings with same name
814 if ( style->labelSettingsNames().contains( saveDlg.name() ) )
815 {
816 const int res = QMessageBox::warning( this, tr( "Save Label Settings" ),
817 tr( "Label settings with the name '%1' already exist. Overwrite?" )
818 .arg( saveDlg.name() ),
819 QMessageBox::Yes | QMessageBox::No );
820 if ( res != QMessageBox::Yes )
821 {
822 return;
823 }
824 style->removeLabelSettings( saveDlg.name() );
825 }
826 const QStringList symbolTags = saveDlg.tags().split( ',' );
827
828 const QgsPalLayerSettings newSettings = layerSettings();
829 style->addLabelSettings( saveDlg.name(), newSettings );
830 style->saveLabelSettings( saveDlg.name(), newSettings, saveDlg.isFavorite(), symbolTags );
831 break;
832 }
833
840 break;
841 }
842}
843
844void QgsLabelingGui::updateGeometryTypeBasedWidgets()
845{
846 Qgis::GeometryType geometryType = mGeomType;
847
848 QgsVectorLayer *vLayer = qobject_cast< QgsVectorLayer * >( mLayer );
849
850 if ( mGeometryGeneratorGroupBox->isChecked() )
851 geometryType = mGeometryGeneratorType->currentData().value<Qgis::GeometryType>();
852 else if ( vLayer )
853 geometryType = vLayer->geometryType();
854
855 // show/hide options based upon geometry type
856 chkMergeLines->setVisible( geometryType == Qgis::GeometryType::Line );
857 mDirectSymbolsFrame->setVisible( geometryType == Qgis::GeometryType::Line );
858 mMinSizeFrame->setVisible( geometryType != Qgis::GeometryType::Point );
859 mPolygonFeatureOptionsFrame->setVisible( geometryType == Qgis::GeometryType::Polygon );
860
861
862 const Qgis::LabelPlacement prevPlacement = static_cast< Qgis::LabelPlacement >( mPlacementModeComboBox->currentData().toInt() );
863 mPlacementModeComboBox->clear();
864
865 switch ( geometryType )
866 {
868 mPlacementModeComboBox->addItem( tr( "Cartographic" ), static_cast< int >( Qgis::LabelPlacement::OrderedPositionsAroundPoint ) );
869 mPlacementModeComboBox->addItem( tr( "Around Point" ), static_cast< int >( Qgis::LabelPlacement::AroundPoint ) );
870 mPlacementModeComboBox->addItem( tr( "Offset from Point" ), static_cast< int >( Qgis::LabelPlacement::OverPoint ) );
871 break;
872
874 mPlacementModeComboBox->addItem( tr( "Parallel" ), static_cast< int >( Qgis::LabelPlacement::Line ) );
875 mPlacementModeComboBox->addItem( tr( "Curved" ), static_cast< int >( Qgis::LabelPlacement::Curved ) );
876 mPlacementModeComboBox->addItem( tr( "Horizontal" ), static_cast< int >( Qgis::LabelPlacement::Horizontal ) );
877 break;
878
880 mPlacementModeComboBox->addItem( tr( "Offset from Centroid" ), static_cast< int >( Qgis::LabelPlacement::OverPoint ) );
881 mPlacementModeComboBox->addItem( tr( "Around Centroid" ), static_cast< int >( Qgis::LabelPlacement::AroundPoint ) );
882 mPlacementModeComboBox->addItem( tr( "Horizontal" ), static_cast< int >( Qgis::LabelPlacement::Horizontal ) );
883 mPlacementModeComboBox->addItem( tr( "Free (Angled)" ), static_cast< int >( Qgis::LabelPlacement::Free ) );
884 mPlacementModeComboBox->addItem( tr( "Using Perimeter" ), static_cast< int >( Qgis::LabelPlacement::Line ) );
885 mPlacementModeComboBox->addItem( tr( "Using Perimeter (Curved)" ), static_cast< int >( Qgis::LabelPlacement::PerimeterCurved ) );
886 mPlacementModeComboBox->addItem( tr( "Outside Polygons" ), static_cast< int >( Qgis::LabelPlacement::OutsidePolygons ) );
887 break;
888
890 break;
892 qFatal( "unknown geometry type unexpected" );
893 }
894
895 if ( mPlacementModeComboBox->findData( static_cast< int >( prevPlacement ) ) != -1 )
896 {
897 mPlacementModeComboBox->setCurrentIndex( mPlacementModeComboBox->findData( static_cast< int >( prevPlacement ) ) );
898 }
899
900 if ( geometryType == Qgis::GeometryType::Point || geometryType == Qgis::GeometryType::Polygon )
901 {
902 // follow placement alignment is only valid for point or polygon layers
903 if ( mFontMultiLineAlignComboBox->findData( static_cast< int >( Qgis::LabelMultiLineAlignment::FollowPlacement ) ) == -1 )
904 mFontMultiLineAlignComboBox->addItem( tr( "Follow Label Placement" ), static_cast< int >( Qgis::LabelMultiLineAlignment::FollowPlacement ) );
905 }
906 else
907 {
908 const int idx = mFontMultiLineAlignComboBox->findData( static_cast< int >( Qgis::LabelMultiLineAlignment::FollowPlacement ) );
909 if ( idx >= 0 )
910 mFontMultiLineAlignComboBox->removeItem( idx );
911 }
912
913 updatePlacementWidgets();
914 updateLinePlacementOptions();
915}
916
917void QgsLabelingGui::showGeometryGeneratorExpressionBuilder()
918{
919 QgsVectorLayer *vLayer = qobject_cast< QgsVectorLayer * >( mLayer );
920 QgsExpressionBuilderDialog expressionBuilder( vLayer );
921
922 expressionBuilder.setExpressionText( mGeometryGenerator->text() );
923 expressionBuilder.setExpressionContext( createExpressionContext() );
924
925 if ( expressionBuilder.exec() )
926 {
927 mGeometryGenerator->setText( expressionBuilder.expressionText() );
928 }
929}
930
931void QgsLabelingGui::validateGeometryGeneratorExpression()
932{
933 bool valid = true;
934
935 QgsVectorLayer *vLayer = qobject_cast< QgsVectorLayer * >( mLayer );
936
937 if ( mGeometryGeneratorGroupBox->isChecked() )
938 {
939 if ( !mPreviewFeature.isValid() && vLayer )
940 vLayer->getFeatures( QgsFeatureRequest().setLimit( 1 ) ).nextFeature( mPreviewFeature );
941
942 QgsExpression expression( mGeometryGenerator->text() );
943 QgsExpressionContext context = createExpressionContext();
944 context.setFeature( mPreviewFeature );
945
946 expression.prepare( &context );
947
948 if ( expression.hasParserError() )
949 {
950 mGeometryGeneratorWarningLabel->setText( expression.parserErrorString() );
951 valid = false;
952 }
953 else
954 {
955 const QVariant result = expression.evaluate( &context );
956 const QgsGeometry geometry = result.value<QgsGeometry>();
957 const Qgis::GeometryType configuredGeometryType = mGeometryGeneratorType->currentData().value<Qgis::GeometryType>();
958 if ( geometry.isNull() )
959 {
960 mGeometryGeneratorWarningLabel->setText( tr( "Result of the expression is not a geometry" ) );
961 valid = false;
962 }
963 else if ( geometry.type() != configuredGeometryType )
964 {
965 mGeometryGeneratorWarningLabel->setText( QStringLiteral( "<p>%1</p><p><a href=\"#determineGeometryGeneratorType\">%2</a></p>" ).arg(
966 tr( "Result of the expression does not match configured geometry type." ),
967 tr( "Change to %1" ).arg( QgsWkbTypes::geometryDisplayString( geometry.type() ) ) ) );
968 valid = false;
969 }
970 }
971 }
972
973 // The collapsible groupbox internally changes the visibility of this
974 // Work around by setting the visibility deferred in the next event loop cycle.
975 QTimer *timer = new QTimer();
976 connect( timer, &QTimer::timeout, this, [this, valid]()
977 {
978 mGeometryGeneratorWarningLabel->setVisible( !valid );
979 } );
980 connect( timer, &QTimer::timeout, timer, &QTimer::deleteLater );
981 timer->start( 0 );
982}
983
984void QgsLabelingGui::determineGeometryGeneratorType()
985{
986 QgsVectorLayer *vLayer = qobject_cast< QgsVectorLayer * >( mLayer );
987 if ( !mPreviewFeature.isValid() && vLayer )
988 vLayer->getFeatures( QgsFeatureRequest().setLimit( 1 ) ).nextFeature( mPreviewFeature );
989
990 QgsExpression expression( mGeometryGenerator->text() );
991 QgsExpressionContext context = createExpressionContext();
992 context.setFeature( mPreviewFeature );
993
994 expression.prepare( &context );
995 const QgsGeometry geometry = expression.evaluate( &context ).value<QgsGeometry>();
996
997 mGeometryGeneratorType->setCurrentIndex( mGeometryGeneratorType->findData( QVariant::fromValue( geometry.type() ) ) );
998}
999
1000void QgsLabelingGui::calloutTypeChanged()
1001{
1002 const QString newCalloutType = mCalloutStyleComboBox->currentData().toString();
1003 QgsCalloutWidget *pew = qobject_cast< QgsCalloutWidget * >( mCalloutStackedWidget->currentWidget() );
1004 if ( pew )
1005 {
1006 if ( pew->callout() && pew->callout()->type() == newCalloutType )
1007 return;
1008 }
1009
1010 // get creation function for new callout from registry
1012 QgsCalloutAbstractMetadata *am = registry->calloutMetadata( newCalloutType );
1013 if ( !am ) // check whether the metadata is assigned
1014 return;
1015
1016 // change callout to a new one (with different type)
1017 // base new callout on existing callout's properties
1018 const std::unique_ptr< QgsCallout > newCallout( am->createCallout( pew && pew->callout() ? pew->callout()->properties( QgsReadWriteContext() ) : QVariantMap(), QgsReadWriteContext() ) );
1019 if ( !newCallout )
1020 return;
1021
1022 updateCalloutWidget( newCallout.get() );
1023 updatePreview();
1024}
1025
1026
1027//
1028// QgsLabelSettingsDialog
1029//
1030
1031QgsLabelSettingsDialog::QgsLabelSettingsDialog( const QgsPalLayerSettings &settings, QgsVectorLayer *layer, QgsMapCanvas *mapCanvas, QWidget *parent,
1032 Qgis::GeometryType geomType )
1033 : QDialog( parent )
1034{
1035 QVBoxLayout *vLayout = new QVBoxLayout();
1036 mWidget = new QgsLabelingGui( layer, mapCanvas, settings, nullptr, geomType );
1037 vLayout->addWidget( mWidget );
1038 mButtonBox = new QDialogButtonBox( QDialogButtonBox::Cancel | QDialogButtonBox::Help | QDialogButtonBox::Ok, Qt::Horizontal );
1039 connect( mButtonBox, &QDialogButtonBox::accepted, this, &QDialog::accept );
1040 connect( mButtonBox, &QDialogButtonBox::rejected, this, &QDialog::reject );
1041 connect( mButtonBox, &QDialogButtonBox::helpRequested, this, &QgsLabelSettingsDialog::showHelp );
1042 vLayout->addWidget( mButtonBox );
1043 setLayout( vLayout );
1044 setWindowTitle( tr( "Label Settings" ) );
1045}
1046
1047QDialogButtonBox *QgsLabelSettingsDialog::buttonBox() const
1048{
1049 return mButtonBox;
1050}
1051
1052void QgsLabelSettingsDialog::showHelp()
1053{
1054 QgsHelp::openHelp( QStringLiteral( "style_library/label_settings.html" ) );
1055}
1056
1057
1058
The Qgis class provides global constants for use throughout the application.
Definition qgis.h:54
@ BelowLine
Labels can be placed below a line feature. Unless MapOrientation is also specified this mode respects...
@ MapOrientation
Signifies that the AboveLine and BelowLine flags should respect the map's orientation rather than the...
@ OnLine
Labels can be placed directly over a line feature.
@ AboveLine
Labels can be placed above a line feature. Unless MapOrientation is also specified this mode respects...
AngleUnit
Units of angles.
Definition qgis.h:4794
@ SecondsOfArc
Seconds of arc.
@ Radians
Square kilometers.
@ Turn
Turn/revolutions.
@ MinutesOfArc
Minutes of arc.
@ MilliradiansSI
Angular milliradians (SI definition, 1/1000 of radian)
@ Degrees
Degrees.
@ Gon
Gon/gradian.
@ MilNATO
Angular mil (NATO definition, 6400 mil = 2PI radians)
LabelOffsetType
Behavior modifier for label offset and distance, only applies in some label placement modes.
Definition qgis.h:1172
LabelPrioritization
Label prioritization.
Definition qgis.h:1111
LabelPlacement
Placement modes which determine how label candidates are generated for a feature.
Definition qgis.h:1125
@ OverPoint
Arranges candidates over a point (or centroid of a polygon), or at a preset offset from the point....
@ Curved
Arranges candidates following the curvature of a line feature. Applies to line layers only.
@ AroundPoint
Arranges candidates in a circle around a point (or centroid of a polygon). Applies to point or polygo...
@ Line
Arranges candidates parallel to a generalised line representing the feature or parallel to a polygon'...
@ Free
Arranges candidates scattered throughout a polygon feature. Candidates are rotated to respect the pol...
@ OrderedPositionsAroundPoint
Candidates are placed in predefined positions around a point. Preference is given to positions with g...
@ Horizontal
Arranges horizontal candidates scattered throughout a polygon feature. Applies to polygon layers only...
@ PerimeterCurved
Arranges candidates following the curvature of a polygon's boundary. Applies to polygon layers only.
@ OutsidePolygons
Candidates are placed outside of polygon boundaries. Applies to polygon layers only.
@ AllowPlacementInsideOfPolygon
Labels can be placed inside a polygon feature.
@ AllowPlacementOutsideOfPolygon
Labels can be placed outside of a polygon feature.
QFlags< LabelLinePlacementFlag > LabelLinePlacementFlags
Line placement flags, which control how candidates are generated for a linear feature.
Definition qgis.h:1221
QFlags< LabelPolygonPlacementFlag > LabelPolygonPlacementFlags
Polygon placement flags, which control how candidates are generated for a polygon feature.
Definition qgis.h:1243
LabelQuadrantPosition
Label quadrant positions.
Definition qgis.h:1186
GeometryType
The geometry types are used to group Qgis::WkbType in a coarse way.
Definition qgis.h:337
@ Polygon
Polygons.
@ Unknown
Unknown types.
@ Null
No geometry.
LabelMultiLineAlignment
Text alignment for multi-line labels.
Definition qgis.h:1269
@ FollowPlacement
Alignment follows placement of label, e.g., labels to the left of a feature will be drawn with right ...
@ Vector
Vector layer.
@ Mesh
Mesh layer. Added in QGIS 3.2.
LabelOverlapHandling
Label overlap handling.
Definition qgis.h:1098
UpsideDownLabelHandling
Handling techniques for upside down labels.
Definition qgis.h:1254
static QIcon getThemeIcon(const QString &name, const QColor &fillColor=QColor(), const QColor &strokeColor=QColor())
Helper to get a theme icon.
static QgsCalloutRegistry * calloutRegistry()
Returns the application's callout registry, used for managing callout types.
Stores metadata about one callout renderer class.
virtual QgsCallout * createCallout(const QVariantMap &properties, const QgsReadWriteContext &context)=0
Create a callout of this type given the map of properties.
Registry of available callout classes.
QgsCalloutAbstractMetadata * calloutMetadata(const QString &type) const
Returns the metadata for specified the specified callout type.
static QgsCallout * defaultCallout()
Create a new instance of a callout with default settings.
QStringList calloutTypes() const
Returns a list of all available callout types.
Base class for widgets which allow control over the properties of callouts.
virtual QgsCallout * callout()=0
Returns the callout defined by the current settings in the widget.
void changed()
Should be emitted whenever configuration changes happened on this symbol layer configuration.
Abstract base class for callout renderers.
Definition qgscallout.h:54
void setEnabled(bool enabled)
Sets whether the callout is enabled.
virtual QString type() const =0
Returns a unique string representing the callout type.
virtual QVariantMap properties(const QgsReadWriteContext &context) const
Returns the properties describing the callout encoded in a string format.
A general purpose distance and area calculator, capable of performing ellipsoid based calculations.
void setSourceCrs(const QgsCoordinateReferenceSystem &crs, const QgsCoordinateTransformContext &context)
Sets source spatial reference system crs.
bool setEllipsoid(const QString &ellipsoid)
Sets the ellipsoid by its acronym.
A generic dialog for building expression strings.
Single scope for storing variables and functions for use within a QgsExpressionContext.
static QgsExpressionContextScope * updateSymbolScope(const QgsSymbol *symbol, QgsExpressionContextScope *symbolScope=nullptr)
Updates a symbol scope related to a QgsSymbol to an expression context.
static QgsExpressionContextScope * projectScope(const QgsProject *project)
Creates a new scope which contains variables and functions relating to a QGIS project.
static QgsExpressionContextScope * atlasScope(const QgsLayoutAtlas *atlas)
Creates a new scope which contains variables and functions relating to a QgsLayoutAtlas.
static QgsExpressionContextScope * meshExpressionScope(QgsMesh::ElementType elementType)
Creates a new scope which contains functions relating to mesh layer element elementType.
static QgsExpressionContextScope * layerScope(const QgsMapLayer *layer)
Creates a new scope which contains variables and functions relating to a QgsMapLayer.
static QgsExpressionContextScope * globalScope()
Creates a new scope which contains variables and functions relating to the global QGIS context.
Expression contexts are used to encapsulate the parameters around which a QgsExpression should be eva...
void setOriginalValueVariable(const QVariant &value)
Sets the original value variable value for the context.
static const QString EXPR_SYMBOL_COLOR
Inbuilt variable name for symbol color variable.
void setFeature(const QgsFeature &feature)
Convenience function for setting a feature for the context.
void setHighlightedVariables(const QStringList &variableNames)
Sets the list of variable names within the context intended to be highlighted to the user.
static const QString EXPR_ORIGINAL_VALUE
Inbuilt variable name for value original value variable.
Class for parsing and evaluation of expressions (formerly called "search strings").
bool nextFeature(QgsFeature &f)
Fetch next feature and stores in f, returns true on success.
This class wraps a request for features to a vector layer (or directly its vector data provider).
The feature class encapsulates a single feature including its unique ID, geometry and a list of field...
Definition qgsfeature.h:58
A geometry is the spatial representation of a feature.
Qgis::GeometryType type
static void initCalloutWidgets()
Initializes callout widgets.
Definition qgsgui.cpp:496
static void openHelp(const QString &key)
Opens help topic for the given help key using default system web browser.
Definition qgshelp.cpp:39
A widget for customising label line anchor settings.
void updateDataDefinedProperties(QgsPropertyCollection &properties) override
Updates a data defined properties collection, correctly setting the values for any properties related...
QgsLabelLineSettings settings() const
Returns the line settings defined by the widget.
void setSettings(const QgsLabelLineSettings &settings)
Sets the line settings to show in the widget.
Contains settings related to how the label engine places and formats labels for line features (or pol...
void setPlacementFlags(Qgis::LabelLinePlacementFlags flags)
Returns the line placement flags, which dictate how line labels can be placed above or below the line...
void setLineAnchorPercent(double percent)
Sets the percent along the line at which labels should be placed.
void setDirectionSymbolPlacement(DirectionSymbolPlacement placement)
Sets the placement for direction symbols.
AnchorType anchorType() const
Returns the line anchor type, which dictates how the lineAnchorPercent() setting is handled.
void setAnchorTextPoint(AnchorTextPoint point)
Sets the line anchor text point, which dictates which part of the label text should be placed at the ...
void setLeftDirectionSymbol(const QString &symbol)
Sets the string to use for left direction arrows.
AnchorTextPoint anchorTextPoint() const
Returns the line anchor text point, which dictates which part of the label text should be placed at t...
void setMergeLines(bool merge)
Sets whether connected line features with identical label text should be merged prior to generating l...
DirectionSymbolPlacement
Placement options for direction symbols.
void setRightDirectionSymbol(const QString &symbol)
Sets the string to use for right direction arrows.
void setAnchorClipping(AnchorClipping clipping)
Sets the line anchor clipping mode, which dictates how line strings are clipped before calculating th...
void setOverrunDistanceMapUnitScale(const QgsMapUnitScale &scale)
Sets the map unit scale for label overrun distance.
double lineAnchorPercent() const
Returns the percent along the line at which labels should be placed.
void setAnchorType(AnchorType type)
Sets the line anchor type, which dictates how the lineAnchorPercent() setting is handled.
void setOverrunDistanceUnit(const Qgis::RenderUnit &unit)
Sets the unit for label overrun distance.
void setOverrunDistance(double distance)
Sets the distance which labels are allowed to overrun past the start or end of line features.
AnchorClipping anchorClipping() const
Returns the line anchor clipping mode, which dictates how line strings are clipped before calculating...
void setReverseDirectionSymbol(bool reversed)
Sets whether the direction symbols should be reversed.
void setAddDirectionSymbol(bool enabled)
Sets whether '<' or '>' (or custom strings set via leftDirectionSymbol and rightDirectionSymbol) will...
A widget for customising label obstacle settings.
void setGeometryType(Qgis::GeometryType type) override
Sets the geometry type of the features to customize the widget accordingly.
QgsLabelObstacleSettings settings() const
Returns the obstacle settings defined by the widget.
void updateDataDefinedProperties(QgsPropertyCollection &properties) override
Updates a data defined properties collection, correctly setting the values for any properties related...
void setSettings(const QgsLabelObstacleSettings &settings)
Sets the obstacle settings to show in the widget.
void setOverlapHandling(Qgis::LabelOverlapHandling handling)
Sets the technique used to handle overlapping labels.
void setPrioritization(Qgis::LabelPrioritization prioritization)
Sets the technique used to prioritize labels.
void setAllowDegradedPlacement(bool allow)
Sets whether labels can be placed in inferior fallback positions if they cannot otherwise be placed.
void setMaximumDistance(double distance)
Sets the maximum distance which labels are allowed to be from their corresponding points.
void setMaximumDistanceMapUnitScale(const QgsMapUnitScale &scale)
Sets the map unit scale for label maximum distance.
void setQuadrant(Qgis::LabelQuadrantPosition quadrant)
Sets the quadrant in which to offset labels from the point.
void setMaximumDistanceUnit(Qgis::RenderUnit unit)
Sets the unit for label maximum distance.
void changed()
Emitted when any of the settings described by the widget are changed.
virtual void setContext(const QgsSymbolWidgetContext &context)
Sets the context in which the symbol widget is shown, e.g., the associated map canvas and expression ...
virtual void setGeometryType(Qgis::GeometryType type)
Sets the geometry type of the features to customize the widget accordingly.
void setDataDefinedProperties(const QgsPropertyCollection &dataDefinedProperties)
Sets the current data defined properties to show in the widget.
QgsPropertyCollection dataDefinedProperties() const
Returns the current data defined properties state as specified in the widget.
A blocking dialog containing a QgsLabelSettingsWidgetBase.
void setMaximumNumberLabels(int number)
Sets the maximum number of labels which should be drawn for this layer.
void setLimitNumberLabelsEnabled(bool enabled)
Sets whether the the number of labels drawn for the layer should be limited.
void setMinimumFeatureSize(double size)
Sets the minimum feature size (in millimeters) for a feature to be labelled.
Map canvas is a class for displaying all GIS data types on a canvas.
Base class for all map layer types.
Definition qgsmaplayer.h:76
Qgis::LayerType type
Definition qgsmaplayer.h:86
Contains settings for how a map layer will be labeled.
bool fitInPolygonOnly
true if only labels which completely fit within a polygon are allowed.
double yOffset
Vertical offset of label.
QgsMapUnitScale labelOffsetMapUnitScale
Map unit scale for label offset.
int fontMaxPixelSize
Maximum pixel size for showing rendered map unit labels (1 - 10000).
void setObstacleSettings(const QgsLabelObstacleSettings &settings)
Sets the label obstacle settings.
const QgsLabelPlacementSettings & placementSettings() const
Returns the label placement settings.
double maxCurvedCharAngleIn
Maximum angle between inside curved label characters (valid range 20.0 to 60.0).
void setFormat(const QgsTextFormat &format)
Sets the label text formatting settings, e.g., font settings, buffer settings, etc.
double zIndex
Z-Index of label, where labels with a higher z-index are rendered on top of labels with a lower z-ind...
void setPolygonPlacementFlags(Qgis::LabelPolygonPlacementFlags flags)
Sets the polygon placement flags, which dictate how polygon labels can be placed.
QString wrapChar
Wrapping character string.
Qgis::LabelOffsetType offsetType
Offset type for layer (only applies in certain placement modes)
double xOffset
Horizontal offset of label.
Qgis::LabelPlacement placement
Label placement mode.
bool drawLabels
Whether to draw labels for this layer.
bool fontLimitPixelSize
true if label sizes should be limited by pixel size.
double minimumScale
The minimum map scale (i.e.
bool scaleVisibility
Set to true to limit label visibility to a range of scales.
double repeatDistance
Distance for repeating labels for a single feature.
bool geometryGeneratorEnabled
Defines if the geometry generator is enabled or not. If disabled, the standard geometry will be taken...
Qgis::LabelMultiLineAlignment multilineAlign
Horizontal alignment of multi-line labels.
bool centroidInside
true if centroid positioned labels must be placed inside their corresponding feature polygon,...
int priority
Label priority.
Qgis::GeometryType geometryGeneratorType
The type of the result geometry of the geometry generator.
bool labelPerPart
true if every part of a multi-part feature should be labeled.
int fontMinPixelSize
Minimum pixel size for showing rendered map unit labels (1 - 1000).
double angleOffset
Label rotation, in degrees clockwise.
double maxCurvedCharAngleOut
Maximum angle between outside curved label characters (valid range -20.0 to -95.0)
const QgsLabelThinningSettings & thinningSettings() const
Returns the label thinning settings.
Qgis::GeometryType layerType
Geometry type of layers associated with these settings.
Qgis::RenderUnit offsetUnits
Units for offsets of label.
void setDataDefinedProperties(const QgsPropertyCollection &collection)
Sets the label's property collection, used for data defined overrides.
bool isExpression
true if this label is made from a expression string, e.g., FieldName || 'mm'
bool preserveRotation
True if label rotation should be preserved during label pin/unpin operations.
bool plusSign
Whether '+' signs should be prepended to positive numeric labels.
QString geometryGenerator
The geometry generator expression. Null if disabled.
const QgsLabelLineSettings & lineSettings() const
Returns the label line settings, which contain settings related to how the label engine places and fo...
QgsMapUnitScale distMapUnitScale
Map unit scale for label feature distance.
QgsStringReplacementCollection substitutions
Substitution collection for automatic text substitution with labels.
int decimals
Number of decimal places to show for numeric labels.
double dist
Distance from feature to the label.
void setRotationUnit(Qgis::AngleUnit angleUnit)
Set unit for rotation of labels.
QgsMapUnitScale repeatDistanceMapUnitScale
Map unit scale for repeating labels for a single feature.
Qgis::RenderUnit distUnits
Units the distance from feature to the label.
bool centroidWhole
true if feature centroid should be calculated from the whole feature, or false if only the visible pa...
Qgis::RenderUnit repeatDistanceUnit
Units for repeating labels for a single feature.
Qgis::UpsideDownLabelHandling upsidedownLabels
Controls whether upside down labels are displayed and how they are handled.
QString fieldName
Name of field (or an expression) to use for label text.
bool formatNumbers
Set to true to format numeric label text as numbers (e.g.
void setCallout(QgsCallout *callout)
Sets the label callout renderer, responsible for drawing label callouts.
double maximumScale
The maximum map scale (i.e.
int autoWrapLength
If non-zero, indicates that label text should be automatically wrapped to (ideally) the specified num...
bool useMaxLineLengthForAutoWrap
If true, indicates that when auto wrapping label text the autoWrapLength length indicates the maximum...
void setUnplacedVisibility(Qgis::UnplacedLabelVisibility visibility)
Sets the layer's unplaced label visibility.
const QgsLabelPointSettings & pointSettings() const
Returns the label point settings, which contain settings related to how the label engine places and f...
bool useSubstitutions
True if substitutions should be applied.
Base class for any widget that can be shown as a inline panel.
void openPanel(QgsPanelWidget *panel)
Open a panel or dialog depending on dock mode setting If dock mode is true this method will emit the ...
static QgsPanelWidget * findParentPanel(QWidget *widget)
Traces through the parents of a widget to find if it is contained within a QgsPanelWidget widget.
bool dockMode()
Returns the dock mode state.
QgsStyle * styleAtPath(const QString &path)
Returns a reference to the style database associated with the project with matching file path.
Encapsulates a QGIS project, including sets of map layers and their styles, layouts,...
Definition qgsproject.h:107
static QgsProject * instance()
Returns the QgsProject singleton instance.
const QgsProjectStyleSettings * styleSettings() const
Returns the project's style settings, which contains settings and properties relating to how a QgsPro...
QgsCoordinateTransformContext transformContext
Definition qgsproject.h:113
A grouped map of multiple QgsProperty objects, each referenced by a integer key value.
A button for controlling property overrides which may apply to a widget.
bool isActive() const
Returns true if the button has an active property.
void changed()
Emitted when property definition changes.
The class is used as a container of context for various read/write operations on other objects.
a dialog for setting properties of a newly saved style.
bool removeLabelSettings(const QString &name)
Removes label settings from the style.
bool saveLabelSettings(const QString &name, const QgsPalLayerSettings &settings, bool favorite, const QStringList &tags)
Adds label settings to the database.
QStringList textFormatNames() const
Returns a list of names of text formats in the style.
bool removeTextFormat(const QString &name)
Removes a text format from the style.
StyleEntity
Enum for Entities involved in a style.
Definition qgsstyle.h:203
@ LabelSettingsEntity
Label settings.
Definition qgsstyle.h:209
@ TextFormatEntity
Text formats.
Definition qgsstyle.h:208
@ SmartgroupEntity
Smart groups.
Definition qgsstyle.h:207
@ Symbol3DEntity
3D symbol entity
Definition qgsstyle.h:211
@ SymbolEntity
Symbols.
Definition qgsstyle.h:204
@ TagEntity
Tags.
Definition qgsstyle.h:205
@ ColorrampEntity
Color ramps.
Definition qgsstyle.h:206
@ LegendPatchShapeEntity
Legend patch shape.
Definition qgsstyle.h:210
static QgsStyle * defaultStyle(bool initialize=true)
Returns the default application-wide style.
Definition qgsstyle.cpp:145
QStringList labelSettingsNames() const
Returns a list of names of label settings in the style.
bool addTextFormat(const QString &name, const QgsTextFormat &format, bool update=false)
Adds a text format with the specified name to the style.
Definition qgsstyle.cpp:369
QgsPalLayerSettings labelSettings(const QString &name) const
Returns the label settings with the specified name.
bool saveTextFormat(const QString &name, const QgsTextFormat &format, bool favorite, const QStringList &tags)
Adds a text format to the database.
Definition qgsstyle.cpp:973
bool addLabelSettings(const QString &name, const QgsPalLayerSettings &settings, bool update=false)
Adds label settings with the specified name to the style.
Definition qgsstyle.cpp:390
Contains settings which reflect the context in which a symbol (or renderer) widget is shown,...
void setMapCanvas(QgsMapCanvas *canvas)
Sets the map canvas associated with the widget.
void setExpressionContext(QgsExpressionContext *context)
Sets the optional expression context used for the widget.
A widget for customizing text formatting settings.
virtual void setContext(const QgsSymbolWidgetContext &context)
Sets the context in which the widget is shown, e.g., the associated map canvas and expression context...
virtual void setFormatFromStyle(const QString &name, QgsStyle::StyleEntity type, const QString &stylePath)
Sets the current text settings from a style entry.
Container for all settings relating to text rendering.
static Q_INVOKABLE QString toString(Qgis::DistanceUnit unit)
Returns a translated string representing a distance unit.
Represents a vector layer which manages a vector based data sets.
QgsFeatureIterator getFeatures(const QgsFeatureRequest &request=QgsFeatureRequest()) const FINAL
Queries the layer for features specified in request.
Q_INVOKABLE Qgis::GeometryType geometryType() const
Returns point, line or polygon.
static QString geometryDisplayString(Qgis::GeometryType type)
Returns a display string for a geometry type.
@ Unknown
Unknown/invalid format.
QgsSignalBlocker< Object > whileBlocking(Object *object)
Temporarily blocks signals from a QObject while calling a single method from the object.
Definition qgis.h:5821