QGIS API Documentation 4.3.0-Master (0cef2469b72)
Loading...
Searching...
No Matches
qgsrelationeditorwidget.cpp
Go to the documentation of this file.
1/***************************************************************************
2 qgsrelationeditorwidget.cpp
3 --------------------------------------
4 Date : 17.5.2013
5 Copyright : (C) 2013 Matthias Kuhn
6 Email : matthias at opengis dot ch
7 ***************************************************************************
8 * *
9 * This program is free software; you can redistribute it and/or modify *
10 * it under the terms of the GNU General Public License as published by *
11 * the Free Software Foundation; either version 2 of the License, or *
12 * (at your option) any later version. *
13 * *
14 ***************************************************************************/
15
17
18#include "qgsactionmenu.h"
19#include "qgsapplication.h"
21#include "qgsexpression.h"
24#include "qgsfeature.h"
25#include "qgsfeatureiterator.h"
26#include "qgsiconutils.h"
27#include "qgslogger.h"
28#include "qgsmapcanvas.h"
30#include "qgsmessagebar.h"
31#include "qgsmessagebaritem.h"
32#include "qgsrelation.h"
34#include "qgsvectorlayerutils.h"
35
36#include <QHBoxLayout>
37#include <QLabel>
38#include <QMessageBox>
39#include <QPushButton>
40#include <QString>
41#include <QTreeWidget>
42
43#include "moc_qgsrelationeditorwidget.cpp"
44
45using namespace Qt::StringLiterals;
46
49QgsFilteredSelectionManager::QgsFilteredSelectionManager( QgsVectorLayer *layer, const QgsFeatureRequest &request, QObject *parent )
50 : QgsVectorLayerSelectionManager( layer, parent )
51 , mRequest( request )
52{
53 if ( !layer )
54 return;
55
56 for ( const auto fid : layer->selectedFeatureIds() )
57 if ( mRequest.acceptFeature( layer->getFeature( fid ) ) )
58 mSelectedFeatureIds << fid;
59
60 connect( layer, &QgsVectorLayer::selectionChanged, this, &QgsFilteredSelectionManager::onSelectionChanged );
61}
62
63const QgsFeatureIds &QgsFilteredSelectionManager::selectedFeatureIds() const
64
65
66{
67 return mSelectedFeatureIds;
68}
69
70int QgsFilteredSelectionManager::selectedFeatureCount()
71{
72 return mSelectedFeatureIds.count();
73}
74
75void QgsFilteredSelectionManager::onSelectionChanged( const QgsFeatureIds &selected, const QgsFeatureIds &deselected, bool clearAndSelect )
76{
77 QgsFeatureIds lselected = selected;
78 if ( clearAndSelect )
79 {
80 mSelectedFeatureIds.clear();
81 }
82 else
83 {
84 for ( const auto fid : deselected )
85 mSelectedFeatureIds.remove( fid );
86 }
87
88 for ( const auto fid : selected )
89 if ( mRequest.acceptFeature( layer()->getFeature( fid ) ) )
90 mSelectedFeatureIds << fid;
91 else
92 lselected.remove( fid );
93
94 emit selectionChanged( lselected, deselected, clearAndSelect );
95}
96
98
99QgsRelationEditorWidget::QgsRelationEditorWidget( const QVariantMap &config, QWidget *parent )
101 , mButtonsVisibility( qgsFlagKeysToValue( config.value( u"buttons"_s ).toString(), QgsRelationEditorWidget::Button::AllButtons ) )
102 , mShowFirstFeature( config.value( u"show_first_feature"_s, true ).toBool() )
103 , mAllowAddChildFeatureWithNoGeometry( config.value( u"allow_add_child_feature_with_no_geometry"_s, false ).toBool() )
104 , mFilterExpression( config.value( u"filter_expression"_s ).toString() )
105{
106 QVBoxLayout *rootLayout = new QVBoxLayout( this );
107 rootLayout->setContentsMargins( 0, 9, 0, 0 );
108
109 // buttons
110 QHBoxLayout *buttonLayout = new QHBoxLayout();
111 buttonLayout->setContentsMargins( 0, 0, 0, 0 );
112 // toggle editing
113 mToggleEditingButton = new QToolButton( this );
114 mToggleEditingButton->setObjectName( u"mToggleEditingButton"_s );
115 mToggleEditingButton->setIcon( QgsApplication::getThemeIcon( u"/mActionToggleEditing.svg"_s ) );
116 mToggleEditingButton->setText( tr( "Toggle Editing" ) );
117 mToggleEditingButton->setEnabled( false );
118 mToggleEditingButton->setCheckable( true );
119 mToggleEditingButton->setToolTip( tr( "Toggle editing mode for child layer" ) );
120 buttonLayout->addWidget( mToggleEditingButton );
121 // save Edits
122 mSaveEditsButton = new QToolButton( this );
123 mSaveEditsButton->setIcon( QgsApplication::getThemeIcon( u"/mActionSaveEdits.svg"_s ) );
124 mSaveEditsButton->setText( tr( "Save Child Layer Edits" ) );
125 mSaveEditsButton->setToolTip( tr( "Save child layer edits" ) );
126 mSaveEditsButton->setEnabled( true );
127 buttonLayout->addWidget( mSaveEditsButton );
128 // add feature with geometry
129 mAddFeatureGeometryButton = new QToolButton( this );
130 mAddFeatureGeometryButton->setObjectName( u"mAddFeatureGeometryButton"_s );
131 buttonLayout->addWidget( mAddFeatureGeometryButton );
132 // add feature
133 mAddFeatureButton = new QToolButton( this );
134 mAddFeatureButton->setIcon( QgsApplication::getThemeIcon( u"/mActionNewTableRow.svg"_s ) );
135 mAddFeatureButton->setText( tr( "Add Child Feature" ) );
136 mAddFeatureButton->setToolTip( tr( "Add child feature" ) );
137 mAddFeatureButton->setObjectName( u"mAddFeatureButton"_s );
138 buttonLayout->addWidget( mAddFeatureButton );
139 // duplicate feature
140 mDuplicateFeatureButton = new QToolButton( this );
141 mDuplicateFeatureButton->setIcon( QgsApplication::getThemeIcon( u"/mActionDuplicateFeature.svg"_s ) );
142 mDuplicateFeatureButton->setText( tr( "Duplicate Child Feature(s)" ) );
143 mDuplicateFeatureButton->setToolTip( tr( "Duplicate selected child feature(s)" ) );
144 mDuplicateFeatureButton->setObjectName( u"mDuplicateFeatureButton"_s );
145 buttonLayout->addWidget( mDuplicateFeatureButton );
146 // delete feature
147 mDeleteFeatureButton = new QToolButton( this );
148 mDeleteFeatureButton->setIcon( QgsApplication::getThemeIcon( u"/mActionDeleteSelectedFeatures.svg"_s ) );
149 mDeleteFeatureButton->setText( tr( "Delete Child Feature(s)" ) );
150 mDeleteFeatureButton->setToolTip( tr( "Delete selected child feature(s)" ) );
151 mDeleteFeatureButton->setObjectName( u"mDeleteFeatureButton"_s );
152 buttonLayout->addWidget( mDeleteFeatureButton );
153 // link feature
154 mLinkFeatureButton = new QToolButton( this );
155 mLinkFeatureButton->setIcon( QgsApplication::getThemeIcon( u"/mActionLink.svg"_s ) );
156 mLinkFeatureButton->setText( tr( "Link Existing Feature(s)" ) );
157 mLinkFeatureButton->setToolTip( tr( "Link existing child feature(s)" ) );
158 mLinkFeatureButton->setObjectName( u"mLinkFeatureButton"_s );
159 buttonLayout->addWidget( mLinkFeatureButton );
160 // unlink feature
161 mUnlinkFeatureButton = new QToolButton( this );
162 mUnlinkFeatureButton->setIcon( QgsApplication::getThemeIcon( u"/mActionUnlink.svg"_s ) );
163 mUnlinkFeatureButton->setText( tr( "Unlink Feature(s)" ) );
164 mUnlinkFeatureButton->setToolTip( tr( "Unlink selected child feature(s)" ) );
165 mUnlinkFeatureButton->setObjectName( u"mUnlinkFeatureButton"_s );
166 buttonLayout->addWidget( mUnlinkFeatureButton );
167 // zoom to linked feature
168 mZoomToFeatureButton = new QToolButton( this );
169 mZoomToFeatureButton->setIcon( QgsApplication::getThemeIcon( u"/mActionZoomToSelected.svg"_s ) );
170 mZoomToFeatureButton->setText( tr( "Zoom To Feature(s)" ) );
171 mZoomToFeatureButton->setToolTip( tr( "Zoom to selected child feature(s)" ) );
172 mZoomToFeatureButton->setObjectName( u"mZoomToFeatureButton"_s );
173 buttonLayout->addWidget( mZoomToFeatureButton );
174 // spacer
175 buttonLayout->addItem( new QSpacerItem( 0, 0, QSizePolicy::Expanding ) );
176 // form view
177 mFormViewButton = new QToolButton( this );
178 mFormViewButton->setText( tr( "Form View" ) );
179 mFormViewButton->setToolTip( tr( "Switch to form view" ) );
180 mFormViewButton->setIcon( QgsApplication::getThemeIcon( u"/mActionPropertyItem.svg"_s ) );
181 mFormViewButton->setCheckable( true );
182 mFormViewButton->setChecked( mViewMode == QgsDualView::AttributeEditor );
183 buttonLayout->addWidget( mFormViewButton );
184 // table view
185 mTableViewButton = new QToolButton( this );
186 mTableViewButton->setText( tr( "Table View" ) );
187 mTableViewButton->setToolTip( tr( "Switch to table view" ) );
188 mTableViewButton->setIcon( QgsApplication::getThemeIcon( u"/mActionOpenTable.svg"_s ) );
189 mTableViewButton->setCheckable( true );
190 mTableViewButton->setChecked( mViewMode == QgsDualView::AttributeTable );
191 buttonLayout->addWidget( mTableViewButton );
192 // button group
193 mViewModeButtonGroup = new QButtonGroup( this );
194 mViewModeButtonGroup->addButton( mFormViewButton, QgsDualView::AttributeEditor );
195 mViewModeButtonGroup->addButton( mTableViewButton, QgsDualView::AttributeTable );
196 // multiedit info label
197 mMultiEditInfoLabel = new QLabel( this );
198 buttonLayout->addWidget( mMultiEditInfoLabel );
199
200 // add buttons layout
201 rootLayout->addLayout( buttonLayout );
202
203 // add stacked widget
204 mStackedWidget = new QStackedWidget( this );
205
206 // add dual view (single feature content)
207 mDualView = new QgsDualView( this );
208 mDualView->setView( mViewMode );
209 connect( mDualView, &QgsDualView::showContextMenuExternally, this, &QgsRelationEditorWidget::showContextMenu );
210
211 // add multi feature editing page
212 mMultiEditStackedWidgetPage = new QWidget( this );
213 {
214 QVBoxLayout *vBoxLayout = new QVBoxLayout();
215 vBoxLayout->setContentsMargins( 0, 0, 0, 0 );
216
217 mMultiEditTreeWidget = new QTreeWidget( this );
218 mMultiEditTreeWidget->setHeaderHidden( true );
219 mMultiEditTreeWidget->setSelectionMode( QTreeWidget::ExtendedSelection );
220 vBoxLayout->addWidget( mMultiEditTreeWidget );
221
222 mMultiEditStackedWidgetPage->setLayout( vBoxLayout );
223 }
224 mStackedWidget->addWidget( mMultiEditStackedWidgetPage );
225
226 mStackedWidget->addWidget( mDualView );
227
228 rootLayout->addWidget( mStackedWidget );
229
230 connect( mViewModeButtonGroup, &QButtonGroup::idClicked, this, static_cast<void ( QgsRelationEditorWidget::* )( int )>( &QgsRelationEditorWidget::setViewMode ) );
231 connect( mToggleEditingButton, &QAbstractButton::clicked, this, &QgsRelationEditorWidget::toggleEditing );
232 connect( mSaveEditsButton, &QAbstractButton::clicked, this, &QgsRelationEditorWidget::saveEdits );
233 connect( mAddFeatureButton, &QAbstractButton::clicked, this, &QgsRelationEditorWidget::addFeature );
234 connect( mAddFeatureGeometryButton, &QAbstractButton::clicked, this, &QgsRelationEditorWidget::addFeatureGeometry );
235 connect( mDuplicateFeatureButton, &QAbstractButton::clicked, this, &QgsRelationEditorWidget::duplicateSelectedFeatures );
236 connect( mDeleteFeatureButton, &QAbstractButton::clicked, this, &QgsRelationEditorWidget::deleteSelectedFeatures );
237 connect( mLinkFeatureButton, &QAbstractButton::clicked, this, &QgsRelationEditorWidget::linkFeature );
238 connect( mUnlinkFeatureButton, &QAbstractButton::clicked, this, &QgsRelationEditorWidget::unlinkSelectedFeatures );
239 connect( mZoomToFeatureButton, &QAbstractButton::clicked, this, &QgsRelationEditorWidget::zoomToSelectedFeatures );
240 connect( mMultiEditTreeWidget, &QTreeWidget::itemSelectionChanged, this, &QgsRelationEditorWidget::multiEditItemSelectionChanged );
241
242 // Set initial state for add/remove etc. buttons
243 updateButtons();
244
245 setLayout( rootLayout );
246}
247
248void QgsRelationEditorWidget::initDualView( QgsVectorLayer *layer, const QgsFeatureRequest &request )
249{
250 if ( multiEditModeActive() )
251 {
252 QgsLogger::warning( tr( "Dual view should not be used in multiple edit mode" ) );
253 return;
254 }
255
256 QgsAttributeEditorContext ctx { mEditorContext };
257 ctx.setParentFormFeature( mFeatureList.first() );
258 mDualView->init( layer, mEditorContext.mapCanvas(), request, ctx, true, mShowFirstFeature );
259 mFeatureSelectionMgr = new QgsFilteredSelectionManager( layer, request, mDualView );
260 mDualView->setFeatureSelectionManager( mFeatureSelectionMgr );
261
262 connect( mFeatureSelectionMgr, &QgsIFeatureSelectionManager::selectionChanged, this, &QgsRelationEditorWidget::updateButtons );
263
264 QIcon icon;
265 QString text;
266 if ( layer->geometryType() == Qgis::GeometryType::Point )
267 {
268 icon = QgsApplication::getThemeIcon( u"/mActionCapturePoint.svg"_s );
269 text = tr( "Add Point Child Feature" );
270 }
271 else if ( layer->geometryType() == Qgis::GeometryType::Line )
272 {
273 icon = QgsApplication::getThemeIcon( u"/mActionCaptureLine.svg"_s );
274 text = tr( "Add Line Child Feature" );
275 }
276 else if ( layer->geometryType() == Qgis::GeometryType::Polygon )
277 {
278 icon = QgsApplication::getThemeIcon( u"/mActionCapturePolygon.svg"_s );
279 text = tr( "Add Polygon Child Feature" );
280 }
281
282 mAddFeatureGeometryButton->setIcon( icon );
283 mAddFeatureGeometryButton->setText( text );
284 mAddFeatureGeometryButton->setToolTip( text );
285
286 updateButtons();
287}
288
290{
291 mEditorContext = context;
292
293 if ( context.mapCanvas() && context.cadDockWidget() )
294 {
295 mMapToolDigitize = make_qobject_unique<QgsMapToolDigitizeFeature>( context.mapCanvas(), context.cadDockWidget() );
296 mMapToolDigitize->setButton( mAddFeatureGeometryButton );
297 }
298
299 updateButtons();
300}
301
303{
304 mDualView->setView( mode );
305 mViewMode = mode;
306}
307
308void QgsRelationEditorWidget::updateButtons()
309{
310 bool toggleEditingButtonEnabled = false;
311 bool canAdd = false;
312 bool canAddGeometry = false;
313 bool canRemove = false;
314 bool canEdit = false;
315 bool canLink = false;
316 bool canUnlink = false;
317 bool spatial = false;
318
319 if ( mRelation.isValid() )
320 {
321 toggleEditingButtonEnabled = mRelation.referencingLayer()->supportsEditing();
323 canAddGeometry = mRelation.referencingLayer()->isEditable();
324 canRemove = mRelation.referencingLayer()->isEditable();
327 canUnlink = mRelation.referencingLayer()->isEditable();
328 spatial = mRelation.referencingLayer()->isSpatial();
329 }
330
331 if ( mNmRelation.isValid() )
332 {
333 toggleEditingButtonEnabled |= mNmRelation.referencedLayer()->supportsEditing();
334 canAdd = mNmRelation.referencedLayer()->isEditable();
335 canAddGeometry = mNmRelation.referencedLayer()->isEditable();
336 canRemove = mNmRelation.referencedLayer()->isEditable();
337 canEdit = mNmRelation.referencedLayer()->isEditable();
338 spatial = mNmRelation.referencedLayer()->isSpatial();
339 }
340
341 const bool selectionNotEmpty = mFeatureSelectionMgr ? mFeatureSelectionMgr->selectedFeatureCount() : false;
342 if ( multiEditModeActive() )
343 {
344 const bool multieditLinkedChildSelected = !selectedChildFeatureIds().isEmpty();
345
346 canAddGeometry = false;
347
348 canRemove = canRemove && multieditLinkedChildSelected;
349
350 // In 1:n relations an element can be linked only to 1 feature
351 canLink = canLink && mNmRelation.isValid();
352 canUnlink = canUnlink && multieditLinkedChildSelected;
353 }
354 else
355 {
356 canRemove = canRemove && selectionNotEmpty;
357 canUnlink = canUnlink && selectionNotEmpty;
358 }
359
360 mToggleEditingButton->setEnabled( toggleEditingButtonEnabled );
361 mAddFeatureButton->setEnabled( canAdd );
362 mAddFeatureGeometryButton->setEnabled( canAddGeometry );
363 mDuplicateFeatureButton->setEnabled( canEdit && selectionNotEmpty );
364 mLinkFeatureButton->setEnabled( canLink );
365 mDeleteFeatureButton->setEnabled( canRemove );
366 mUnlinkFeatureButton->setEnabled( canUnlink );
367 mZoomToFeatureButton->setEnabled( selectionNotEmpty );
368 mToggleEditingButton->setChecked( canEdit );
369 mSaveEditsButton->setEnabled( canEdit || canLink || canUnlink );
370
371 mToggleEditingButton->setVisible( !mLayerInSameTransactionGroup );
372
373 mLinkFeatureButton->setVisible( mButtonsVisibility.testFlag( QgsRelationEditorWidget::Button::Link ) );
374 mUnlinkFeatureButton->setVisible( mButtonsVisibility.testFlag( QgsRelationEditorWidget::Button::Unlink ) );
375 mSaveEditsButton->setVisible( mButtonsVisibility.testFlag( QgsRelationEditorWidget::Button::SaveChildEdits ) && !mLayerInSameTransactionGroup );
376 mAddFeatureButton->setVisible( mButtonsVisibility.testFlag( QgsRelationEditorWidget::Button::AddChildFeature ) && !( spatial && !mAllowAddChildFeatureWithNoGeometry ) );
377 mAddFeatureGeometryButton->setVisible( mButtonsVisibility.testFlag( QgsRelationEditorWidget::Button::AddChildFeature ) && mEditorContext.mapCanvas() && mEditorContext.cadDockWidget() && spatial );
378 mDuplicateFeatureButton->setVisible( mButtonsVisibility.testFlag( QgsRelationEditorWidget::Button::DuplicateChildFeature ) );
379 mDeleteFeatureButton->setVisible( mButtonsVisibility.testFlag( QgsRelationEditorWidget::Button::DeleteChildFeature ) );
380 mZoomToFeatureButton->setVisible( mButtonsVisibility.testFlag( QgsRelationEditorWidget::Button::ZoomToChildFeature ) && mEditorContext.mapCanvas() && spatial );
381}
382
383void QgsRelationEditorWidget::addFeature()
384{
386
387 if ( !multiEditModeActive() )
388 return;
389
390 mMultiEditTreeWidget->blockSignals( true );
391 mMultiEdit1NJustAddedIds = addedFeatures;
392 QTreeWidgetItemIterator treeWidgetItemIterator( mMultiEditTreeWidget );
393 while ( *treeWidgetItemIterator )
394 {
395 if ( ( *treeWidgetItemIterator )->data( 0, static_cast<int>( MultiEditTreeWidgetRole::FeatureType ) ).toInt() != static_cast<int>( MultiEditFeatureType::Child ) )
396 {
397 ++treeWidgetItemIterator;
398 continue;
399 }
400
401 if ( addedFeatures.contains( ( *treeWidgetItemIterator )->data( 0, static_cast<int>( MultiEditTreeWidgetRole::FeatureId ) ).toInt() ) )
402 ( *treeWidgetItemIterator )->setSelected( true );
403
404 ++treeWidgetItemIterator;
405 }
406 mMultiEditTreeWidget->blockSignals( false );
407
408 updateUi();
409 updateButtons();
410}
411
412void QgsRelationEditorWidget::addFeatureGeometry()
413{
414 if ( multiEditModeActive() )
415 {
416 QgsLogger::warning( tr( "Adding a geometry feature is not supported in multiple edit mode" ) );
417 return;
418 }
419
420 QgsVectorLayer *layer = nullptr;
421 if ( mNmRelation.isValid() )
422 layer = mNmRelation.referencedLayer();
423 else
424 layer = mRelation.referencingLayer();
425
426 mMapToolDigitize->setLayer( layer );
427
428 // window is always on top, so we hide it to digitize without seeing it
429 if ( window()->objectName() != "QgisApp"_L1 )
430 {
431 window()->setVisible( false );
432 }
433 setMapTool( mMapToolDigitize );
434
435 connect( mMapToolDigitize, &QgsMapToolDigitizeFeature::digitizingCompleted, this, &QgsRelationEditorWidget::onDigitizingCompleted );
436
437 connect( mMapToolDigitize, &QgsMapToolDigitizeFeature::digitizingCanceled, this, &QgsRelationEditorWidget::onDigitizingCanceled );
438
439 if ( auto *lMainMessageBar = mEditorContext.mainMessageBar() )
440 {
441 const QString displayString = QgsVectorLayerUtils::getFeatureDisplayString( layer, mFeatureList.first() );
442
443 const QString title = tr( "Create child feature for parent %1 \"%2\"" ).arg( mRelation.referencedLayer()->name(), displayString );
444 const QString msg = tr( "Digitize the geometry for the new feature on layer %1. Press &lt;ESC&gt; to cancel." ).arg( layer->name() );
445 mMessageBarItem = QgsMessageBar::createMessage( title, msg, this );
446 lMainMessageBar->pushItem( mMessageBarItem );
447 }
448}
449
450void QgsRelationEditorWidget::onDigitizingCompleted( const QgsFeature &feature )
451{
452 // we have to cleanup the digitizing first, before showing the attribute form for the
453 // new feature
454 digitizingFinished();
455
457}
458
459void QgsRelationEditorWidget::multiEditItemSelectionChanged()
460{
461 const QList<QTreeWidgetItem *> selectedItems = mMultiEditTreeWidget->selectedItems();
462
463 // Select all items pointing to the same feature
464 // but only if we are not deselecting.
465 if ( selectedItems.size() == 1 && mMultiEditPreviousSelectedItems.size() <= 1 )
466 {
467 if ( selectedItems.first()->data( 0, static_cast<int>( MultiEditTreeWidgetRole::FeatureType ) ).toInt() == static_cast<int>( MultiEditFeatureType::Child ) )
468 {
469 mMultiEditTreeWidget->blockSignals( true );
470
471 const QgsFeatureId featureIdSelectedItem = selectedItems.first()->data( 0, static_cast<int>( MultiEditTreeWidgetRole::FeatureId ) ).toInt();
472
473 QTreeWidgetItemIterator treeWidgetItemIterator( mMultiEditTreeWidget );
474 while ( *treeWidgetItemIterator )
475 {
476 if ( ( *treeWidgetItemIterator )->data( 0, static_cast<int>( MultiEditTreeWidgetRole::FeatureType ) ).toInt() != static_cast<int>( MultiEditFeatureType::Child ) )
477 {
478 ++treeWidgetItemIterator;
479 continue;
480 }
481
482 const QgsFeatureId featureIdCurrentItem = ( *treeWidgetItemIterator )->data( 0, static_cast<int>( MultiEditTreeWidgetRole::FeatureId ) ).toInt();
483 if ( mNmRelation.isValid() )
484 {
485 if ( featureIdSelectedItem == featureIdCurrentItem )
486 ( *treeWidgetItemIterator )->setSelected( true );
487 }
488 else
489 {
490 if ( !mMultiEdit1NJustAddedIds.contains( featureIdSelectedItem ) )
491 break;
492
493 if ( mMultiEdit1NJustAddedIds.contains( featureIdCurrentItem ) )
494 ( *treeWidgetItemIterator )->setSelected( true );
495 }
496
497 ++treeWidgetItemIterator;
498 }
499 mMultiEditTreeWidget->blockSignals( false );
500 }
501 }
502 mMultiEditPreviousSelectedItems = selectedItems;
503 updateButtons();
504}
505
506void QgsRelationEditorWidget::linkFeature()
507{
509}
510
511void QgsRelationEditorWidget::toggleEditing( bool state ) // cppcheck-suppress duplInheritedMember
512{
514
515 updateButtons();
516}
517
519{
520 if ( !mRelation.isValid() || mFeatureList.isEmpty() || !mFeatureList.first().isValid() )
521 return;
522
523 if ( !isVisible() )
524 return;
525
526 if ( multiEditModeActive() )
527 updateUiMultiEdit();
528 else
529 updateUiSingleEdit();
530}
531
533{
534 mButtonsVisibility = buttons;
535 updateButtons();
536}
537
539{
540 Buttons buttons;
541 if ( mLinkFeatureButton->isVisible() )
542 buttons |= Button::Link;
543 if ( mUnlinkFeatureButton->isVisible() )
544 buttons |= Button::Unlink;
545 if ( mSaveEditsButton->isVisible() )
546 buttons |= Button::SaveChildEdits;
547 if ( mAddFeatureButton->isVisible() )
548 buttons |= Button::AddChildFeature;
549 if ( mDuplicateFeatureButton->isVisible() )
551 if ( mDeleteFeatureButton->isVisible() )
553 if ( mZoomToFeatureButton->isVisible() )
555 return buttons;
556}
557
558void QgsRelationEditorWidget::parentFormValueChanged( const QString &attribute, const QVariant &newValue )
559{
560 mDualView->parentFormValueChanged( attribute, newValue );
561}
562
563void QgsRelationEditorWidget::showContextMenu( QgsActionMenu *menu, const QgsFeatureId fid )
564{
566 {
567 QAction *qAction = nullptr;
568
569 if ( mButtonsVisibility.testFlag( QgsRelationEditorWidget::Button::DeleteChildFeature ) )
570 {
571 qAction = menu->addAction( QgsApplication::getThemeIcon( u"/mActionDeleteSelected.svg"_s ), tr( "Delete Feature" ) );
572 connect( qAction, &QAction::triggered, this, [this, fid]() { deleteFeature( fid ); } );
573 }
574
575 if ( mButtonsVisibility.testFlag( QgsRelationEditorWidget::Button::Unlink ) )
576 {
577 qAction = menu->addAction( QgsApplication::getThemeIcon( u"/mActionUnlink.svg"_s ), tr( "Unlink Feature" ) );
578 connect( qAction, &QAction::triggered, this, [this, fid]() { unlinkFeature( fid ); } );
579 }
580 }
581}
582
583void QgsRelationEditorWidget::setMapTool( QgsMapTool *mapTool )
584{
585 QgsMapCanvas *mapCanvas = mEditorContext.mapCanvas();
586
587 mapCanvas->setMapTool( mapTool );
588 mapCanvas->window()->raise();
589 mapCanvas->activateWindow();
590 mapCanvas->setFocus();
591 connect( mapTool, &QgsMapTool::deactivated, this, &QgsRelationEditorWidget::mapToolDeactivated );
592}
593
594void QgsRelationEditorWidget::unsetMapTool()
595{
596 QgsMapCanvas *mapCanvas = mEditorContext.mapCanvas();
597
598 // this will call mapToolDeactivated
599 mapCanvas->unsetMapTool( mMapToolDigitize );
600
601 disconnect( mMapToolDigitize, &QgsMapToolDigitizeFeature::digitizingCompleted, this, &QgsRelationEditorWidget::onDigitizingCompleted );
602}
603
604QgsFeatureIds QgsRelationEditorWidget::selectedChildFeatureIds() const
605{
606 if ( multiEditModeActive() )
607 {
608 QgsFeatureIds featureIds;
609 for ( QTreeWidgetItem *treeWidgetItem : mMultiEditTreeWidget->selectedItems() )
610 {
611 if ( static_cast<MultiEditFeatureType>( treeWidgetItem->data( 0, static_cast<int>( MultiEditTreeWidgetRole::FeatureType ) ).toInt() ) != MultiEditFeatureType::Child )
612 continue;
613
614 featureIds.insert( treeWidgetItem->data( 0, static_cast<int>( MultiEditTreeWidgetRole::FeatureId ) ).toLongLong() );
615 }
616 return featureIds;
617 }
618 else if ( mFeatureSelectionMgr )
619 {
620 return mFeatureSelectionMgr->selectedFeatureIds();
621 }
622 else
623 {
624 return {};
625 }
626}
627
628void QgsRelationEditorWidget::updateUiSingleEdit()
629{
630 mFormViewButton->setVisible( true );
631 mTableViewButton->setVisible( true );
632 mMultiEditInfoLabel->setVisible( false );
633
634 mStackedWidget->setCurrentWidget( mDualView );
635
636 QgsFeatureRequest request = mRelation.getRelatedFeaturesRequest( mFeatureList.first() );
637 QgsVectorLayer *layer = nullptr;
638 if ( mNmRelation.isValid() )
639 {
640 QgsFeature fet;
641 QgsFeatureRequest nmRequest;
642
643 QgsFeatureIterator it = mRelation.referencingLayer()->getFeatures( request );
644 QStringList filters;
645
646 while ( it.nextFeature( fet ) )
647 {
648 QString filter = mNmRelation.getReferencedFeatureRequest( fet ).filterExpression()->expression();
649 filters << filter.prepend( '(' ).append( ')' );
650 }
651
652 QString reducedExpression;
653 if ( QgsExpression::attemptReduceToInClause( filters, reducedExpression ) )
654 {
655 nmRequest.setFilterExpression( reducedExpression );
656 }
657 else
658 {
659 nmRequest.setFilterExpression( filters.join( " OR "_L1 ) );
660 }
661
662 request = std::move( nmRequest );
663 layer = mNmRelation.referencedLayer();
664 }
665 else if ( mRelation.referencingLayer() )
666 {
667 layer = mRelation.referencingLayer();
668 }
669
670 if ( !layer )
671 return;
672
673 // don't recreate all the widget from scratch if only the request has changed
674 if ( !mDualView->masterModel() || layer != mDualView->masterModel()->layer() )
675 {
676 initDualView( layer, request );
677 }
678 else
679 {
680 mFeatureSelectionMgr = new QgsFilteredSelectionManager( layer, request, mDualView );
681 mDualView->setFeatureSelectionManager( mFeatureSelectionMgr );
682 connect( mFeatureSelectionMgr, &QgsIFeatureSelectionManager::selectionChanged, this, &QgsRelationEditorWidget::updateButtons );
683
684 mDualView->setRequest( request );
685 mDualView->masterModel()->loadLayer();
686
687 updateButtons();
688 }
689}
690
691void QgsRelationEditorWidget::updateUiMultiEdit()
692{
693 mFormViewButton->setVisible( false );
694 mTableViewButton->setVisible( false );
695 mMultiEditInfoLabel->setVisible( true );
696
697 mStackedWidget->setCurrentWidget( mMultiEditStackedWidgetPage );
698
699 QList<QTreeWidgetItem *> parentTreeWidgetItems;
700
701 QgsFeatureIds featureIdsMixedValues;
702 QMultiMap<QTreeWidgetItem *, QgsFeatureId> multimapChildFeatures;
703
704 mMultiEditTreeWidget->clear();
705 for ( const QgsFeature &featureParent : std::as_const( mFeatureList ) )
706 {
707 QTreeWidgetItem *treeWidgetItem = createMultiEditTreeWidgetItem( featureParent, mRelation.referencedLayer(), MultiEditFeatureType::Parent );
708
709 // Parent feature items are not selectable
710 treeWidgetItem->setFlags( Qt::ItemIsEnabled );
711
712 parentTreeWidgetItems.append( treeWidgetItem );
713
714 // Get child features
715 const QgsFeatureRequest request = relation().getRelatedFeaturesRequest( featureParent );
716 QgsFeatureIterator featureIterator = mRelation.referencingLayer()->getFeatures( request );
717 QgsFeature featureChild;
718 while ( featureIterator.nextFeature( featureChild ) )
719 {
720 if ( mNmRelation.isValid() )
721 {
722 const QgsFeatureRequest requestFinalChild = mNmRelation.getReferencedFeatureRequest( featureChild );
723 QgsFeatureIterator featureIteratorFinalChild = mNmRelation.referencedLayer()->getFeatures( requestFinalChild );
724 QgsFeature featureChildChild;
725 while ( featureIteratorFinalChild.nextFeature( featureChildChild ) )
726 {
727 QTreeWidgetItem *treeWidgetItemChild = createMultiEditTreeWidgetItem( featureChildChild, mNmRelation.referencedLayer(), MultiEditFeatureType::Child );
728
729 treeWidgetItem->addChild( treeWidgetItemChild );
730
731 featureIdsMixedValues.insert( featureChildChild.id() );
732 multimapChildFeatures.insert( treeWidgetItem, featureChildChild.id() );
733 }
734 }
735 else
736 {
737 QTreeWidgetItem *treeWidgetItemChild = createMultiEditTreeWidgetItem( featureChild, mRelation.referencingLayer(), MultiEditFeatureType::Child );
738 treeWidgetItem->addChild( treeWidgetItemChild );
739
740 featureIdsMixedValues.insert( featureChild.id() );
741 }
742 }
743
744 mMultiEditTreeWidget->addTopLevelItem( treeWidgetItem );
745 treeWidgetItem->setExpanded( true );
746 }
747
748 // Set mixed values indicator (Green or Orange)
749 //
750 // Green:
751 // n:m and 1:n: 0 child features available
752 // n:m with no mixed values
753 // Orange:
754 // n:m with mixed values
755 // 1:n always, including when we pseudo know that feature are related (just added feature)
756 //
757 // See https://github.com/qgis/QGIS/pull/45703
758 //
759 if ( mNmRelation.isValid() )
760 {
761 QgsFeatureIds::iterator iterator = featureIdsMixedValues.begin();
762 while ( iterator != featureIdsMixedValues.end() )
763 {
764 bool mixedValues = false;
765 for ( QTreeWidgetItem *parentTreeWidgetItem : parentTreeWidgetItems )
766 {
767 if ( !multimapChildFeatures.values( parentTreeWidgetItem ).contains( *iterator ) )
768 {
769 mixedValues = true;
770 break;
771 }
772 }
773
774 if ( !mixedValues )
775 {
776 iterator = featureIdsMixedValues.erase( iterator );
777 continue;
778 }
779
780 ++iterator;
781 }
782 }
783
784 // Set multiedit info label
785 if ( featureIdsMixedValues.isEmpty() )
786 {
787 QIcon icon = QgsApplication::getThemeIcon( u"/multieditSameValues.svg"_s );
788 mMultiEditInfoLabel->setPixmap( icon.pixmap( mMultiEditInfoLabel->height(), mMultiEditInfoLabel->height() ) );
789 mMultiEditInfoLabel->setToolTip( tr( "All features in selection have equal relations" ) );
790 }
791 else
792 {
793 QIcon icon = QgsApplication::getThemeIcon( u"/multieditMixedValues.svg"_s );
794 mMultiEditInfoLabel->setPixmap( icon.pixmap( mMultiEditInfoLabel->height(), mMultiEditInfoLabel->height() ) );
795 mMultiEditInfoLabel->setToolTip( tr( "Some features in selection have different relations" ) );
796
797 // Set italic font for mixed values
798 QFont fontItalic = mMultiEditTreeWidget->font();
799 fontItalic.setItalic( true );
800 for ( QTreeWidgetItem *parentTreeWidgetItem : parentTreeWidgetItems )
801 {
802 for ( int childIndex = 0; childIndex < parentTreeWidgetItem->childCount(); ++childIndex )
803 {
804 QTreeWidgetItem *childItem = parentTreeWidgetItem->child( childIndex );
805 const QgsFeatureId featureIdCurrentItem = childItem->data( 0, static_cast<int>( MultiEditTreeWidgetRole::FeatureId ) ).toInt();
806 if ( featureIdsMixedValues.contains( featureIdCurrentItem ) )
807 childItem->setFont( 0, fontItalic );
808 }
809 }
810 }
811}
812
813QTreeWidgetItem *QgsRelationEditorWidget::createMultiEditTreeWidgetItem( const QgsFeature &feature, QgsVectorLayer *layer, MultiEditFeatureType type )
814{
815 QTreeWidgetItem *treeWidgetItem = new QTreeWidgetItem();
816 treeWidgetItem->setText( 0, QgsVectorLayerUtils::getFeatureDisplayString( layer, feature ) );
817 treeWidgetItem->setIcon( 0, QgsIconUtils::iconForLayer( layer ) );
818 treeWidgetItem->setData( 0, static_cast<int>( MultiEditTreeWidgetRole::FeatureType ), static_cast<int>( type ) );
819 treeWidgetItem->setData( 0, static_cast<int>( MultiEditTreeWidgetRole::FeatureId ), feature.id() );
820 return treeWidgetItem;
821}
822
823void QgsRelationEditorWidget::onDigitizingCanceled()
824{
825 digitizingFinished();
826}
827
828void QgsRelationEditorWidget::digitizingFinished()
829{
830 window()->setVisible( true );
831 window()->raise();
832 window()->activateWindow();
833 unsetMapTool();
834}
835
836void QgsRelationEditorWidget::mapToolDeactivated()
837{
838 if ( mEditorContext.mainMessageBar() && mMessageBarItem )
839 {
840 mEditorContext.mainMessageBar()->popWidget( mMessageBarItem );
841 }
842 mMessageBarItem = nullptr;
843}
844
846{
847 return QVariantMap(
848 { { "buttons", qgsFlagValueToKeys( visibleButtons() ) },
849 { "show_first_feature", mShowFirstFeature },
850 { "allow_add_child_feature_with_no_geometry", mAllowAddChildFeatureWithNoGeometry },
851 { "filter_expression", mFilterExpression } }
852 );
853}
854
856{
857 mButtonsVisibility = qgsFlagKeysToValue( config.value( u"buttons"_s ).toString(), QgsRelationEditorWidget::Button::AllButtons );
858 mShowFirstFeature = config.value( u"show_first_feature"_s, true ).toBool();
859 mAllowAddChildFeatureWithNoGeometry = config.value( u"allow_add_child_feature_with_no_geometry"_s, false ).toBool();
860 mFilterExpression = config.value( u"filter_expression"_s ).toString();
861 updateButtons();
862}
863
865{
866 Q_UNUSED( newRelation );
867 Q_UNUSED( newFeature );
868
869 if ( !mRelation.isValid() )
870 return;
871
872 disconnect( mRelation.referencingLayer(), &QgsVectorLayer::editingStarted, this, &QgsRelationEditorWidget::updateButtons );
873 disconnect( mRelation.referencingLayer(), &QgsVectorLayer::editingStopped, this, &QgsRelationEditorWidget::updateButtons );
874}
875
877{
878 if ( !mRelation.isValid() || mFeatureList.isEmpty() )
879 {
880 updateButtons();
881 return;
882 }
883
884 connect( mRelation.referencingLayer(), &QgsVectorLayer::editingStarted, this, &QgsRelationEditorWidget::updateButtons );
885 connect( mRelation.referencingLayer(), &QgsVectorLayer::editingStopped, this, &QgsRelationEditorWidget::updateButtons );
886
887 updateButtons();
888
889 const QgsFeatureRequest myRequest = mRelation.getRelatedFeaturesRequest( mFeatureList.first() );
890 initDualView( mRelation.referencingLayer(), myRequest );
891}
892
893void QgsRelationEditorWidget::beforeSetRelations( const QgsRelation &newRelation, const QgsRelation &newNmRelation )
894{
895 Q_UNUSED( newRelation );
896 Q_UNUSED( newNmRelation );
897
898 if ( mRelation.isValid() )
899 {
900 disconnect( mRelation.referencingLayer(), &QgsVectorLayer::editingStarted, this, &QgsRelationEditorWidget::updateButtons );
901 disconnect( mRelation.referencingLayer(), &QgsVectorLayer::editingStopped, this, &QgsRelationEditorWidget::updateButtons );
902 }
903
904 if ( mNmRelation.isValid() )
905 {
906 disconnect( mNmRelation.referencedLayer(), &QgsVectorLayer::editingStarted, this, &QgsRelationEditorWidget::updateButtons );
907 disconnect( mNmRelation.referencedLayer(), &QgsVectorLayer::editingStopped, this, &QgsRelationEditorWidget::updateButtons );
908 }
909}
910
912{
913 if ( !mRelation.isValid() )
914 return;
915
916 connect( mRelation.referencingLayer(), &QgsVectorLayer::editingStarted, this, &QgsRelationEditorWidget::updateButtons );
917 connect( mRelation.referencingLayer(), &QgsVectorLayer::editingStopped, this, &QgsRelationEditorWidget::updateButtons );
918
919 if ( mNmRelation.isValid() )
920 {
921 connect( mNmRelation.referencedLayer(), &QgsVectorLayer::editingStarted, this, &QgsRelationEditorWidget::updateButtons );
922 connect( mNmRelation.referencedLayer(), &QgsVectorLayer::editingStopped, this, &QgsRelationEditorWidget::updateButtons );
923 }
924
925 updateButtons();
926}
927
932
934{
935 const QgsFeatureIds selectedFids = selectedChildFeatureIds();
936 unlinkFeatures( selectedFids );
937}
938
940{
941 duplicateFeatures( mFeatureSelectionMgr->selectedFeatureIds() );
942}
943
945{
946 duplicateFeatures( mFeatureSelectionMgr->selectedFeatureIds() );
947}
948
950{
951 const QgsFeatureIds selectedFids = selectedChildFeatureIds();
952 deleteFeatures( selectedFids );
953}
954
956{
957 QgsMapCanvas *c = mEditorContext.mapCanvas();
958 if ( !c )
959 return;
960
961 c->zoomToFeatureIds( mNmRelation.isValid() ? mNmRelation.referencedLayer() : mRelation.referencingLayer(), mFeatureSelectionMgr->selectedFeatureIds() );
962}
963
965
966
969{
970 setupUi( this );
971 connect( mEditExpression, &QAbstractButton::clicked, this, &QgsRelationEditorConfigWidget::mEditExpression_clicked );
972
973 // Make filter depending on link button
974 filterExpressionLabel->setEnabled( mRelationShowLinkCheckBox->isChecked() );
975 mEditExpression->setEnabled( mRelationShowLinkCheckBox->isChecked() );
976 mFilterExpression->setEnabled( mRelationShowLinkCheckBox->isChecked() );
977 connect( mRelationShowLinkCheckBox, &QCheckBox::toggled, filterExpressionLabel, &QLabel::setEnabled );
978 connect( mRelationShowLinkCheckBox, &QCheckBox::toggled, mEditExpression, &QToolButton::setEnabled );
979 connect( mRelationShowLinkCheckBox, &QCheckBox::toggled, mFilterExpression, &QTextEdit::setEnabled );
980
981 // Make add feature with no geometry depending on add button
982 mAllowAddChildFeatureWithNoGeometry->setEnabled( mRelationShowAddChildCheckBox->isChecked() );
983 connect( mRelationShowAddChildCheckBox, &QCheckBox::toggled, mAllowAddChildFeatureWithNoGeometry, &QCheckBox::setEnabled );
984}
985
987{
988 QgsVectorLayer *vl = nullptr;
989
990 if ( nmRelation().isValid() )
991 {
993 }
994 else
995 {
996 vl = relation().referencingLayer();
997 }
998
999 // Show expression builder
1001 QgsExpressionBuilderDialog dlg( vl, mFilterExpression->toPlainText(), this, u"generic"_s, context );
1002 dlg.setWindowTitle( tr( "Edit Filter Expression of Target Layer" ) );
1003
1004 if ( dlg.exec() == QDialog::Accepted )
1005 {
1006 mFilterExpression->setPlainText( dlg.expressionBuilder()->expressionText() );
1007 }
1008}
1009
1011{
1013 buttons.setFlag( QgsRelationEditorWidget::Button::Link, mRelationShowLinkCheckBox->isChecked() );
1014 buttons.setFlag( QgsRelationEditorWidget::Button::Unlink, mRelationShowUnlinkCheckBox->isChecked() );
1015 buttons.setFlag( QgsRelationEditorWidget::Button::AddChildFeature, mRelationShowAddChildCheckBox->isChecked() );
1016 buttons.setFlag( QgsRelationEditorWidget::Button::DuplicateChildFeature, mRelationShowDuplicateChildFeatureCheckBox->isChecked() );
1017 buttons.setFlag( QgsRelationEditorWidget::Button::ZoomToChildFeature, mRelationShowZoomToFeatureCheckBox->isChecked() );
1018 buttons.setFlag( QgsRelationEditorWidget::Button::DeleteChildFeature, mRelationDeleteChildFeatureCheckBox->isChecked() );
1019 buttons.setFlag( QgsRelationEditorWidget::Button::SaveChildEdits, mRelationShowSaveChildEditsCheckBox->isChecked() );
1020
1021 return QVariantMap(
1022 { { "buttons", qgsFlagValueToKeys( buttons ) },
1023 { "show_first_feature", mShowFirstFeature->isChecked() },
1024 { "allow_add_child_feature_with_no_geometry", mAllowAddChildFeatureWithNoGeometry->isChecked() },
1025 { "filter_expression", mFilterExpression->toPlainText() } }
1026 );
1027}
1028
1030{
1032
1033 mRelationShowLinkCheckBox->setChecked( buttons.testFlag( QgsRelationEditorWidget::Button::Link ) );
1034 mRelationShowUnlinkCheckBox->setChecked( buttons.testFlag( QgsRelationEditorWidget::Button::Unlink ) );
1035 mRelationShowAddChildCheckBox->setChecked( buttons.testFlag( QgsRelationEditorWidget::Button::AddChildFeature ) );
1036 mRelationShowDuplicateChildFeatureCheckBox->setChecked( buttons.testFlag( QgsRelationEditorWidget::Button::DuplicateChildFeature ) );
1037 mRelationShowZoomToFeatureCheckBox->setChecked( buttons.testFlag( QgsRelationEditorWidget::Button::ZoomToChildFeature ) );
1038 mRelationDeleteChildFeatureCheckBox->setChecked( buttons.testFlag( QgsRelationEditorWidget::Button::DeleteChildFeature ) );
1039 mRelationShowSaveChildEditsCheckBox->setChecked( buttons.testFlag( QgsRelationEditorWidget::Button::SaveChildEdits ) );
1040 mShowFirstFeature->setChecked( config.value( u"show_first_feature"_s, true ).toBool() );
1041 mAllowAddChildFeatureWithNoGeometry->setChecked( config.value( u"allow_add_child_feature_with_no_geometry"_s, false ).toBool() );
1042 mFilterExpression->setPlainText( config.value( u"filter_expression"_s ).toString() );
1043}
1044
1045
1047
1048
1049#ifndef SIP_RUN
1052
1054{
1055 return u"relation_editor"_s;
1056}
1057
1059{
1060 return QObject::tr( "Relation Editor" );
1061}
1062
1063QgsAbstractRelationEditorWidget *QgsRelationEditorWidgetFactory::create( const QVariantMap &config, QWidget *parent ) const
1064{
1065 return new QgsRelationEditorWidget( config, parent );
1066}
1067
1069{
1070 return static_cast<QgsAbstractRelationEditorConfigWidget *>( new QgsRelationEditorConfigWidget( relation, parent ) );
1071}
1072#endif
@ Point
Points.
Definition qgis.h:400
@ Line
Lines.
Definition qgis.h:401
@ Polygon
Polygons.
Definition qgis.h:402
Abstract base class for configurable relation widget types.
QgsRelation relation() const
Returns the relation for which this configuration widget applies.
virtual QgsRelation nmRelation() const
Returns the nm relation for which this configuration widget applies.
QgsAbstractRelationEditorConfigWidget(const QgsRelation &relation, QWidget *parent)
Create a new configuration widget.
Base class to build new relation widgets.
void toggleEditing(bool state)
Toggles editing state of the widget.
QgsFeatureIds addFeature(const QgsGeometry &geometry=QgsGeometry())
Adds new features with given geometry Returns the Id of added features.
void deleteFeatures(const QgsFeatureIds &fids)
Deletes the features with fids.
void linkFeature(const QString &filterExpression=QString())
Links a new feature to the relation.
QgsAbstractRelationEditorWidget(const QVariantMap &config, QWidget *parent=nullptr)
Constructor.
QgsRelation relation() const
Returns the relation.
void unlinkFeatures(const QgsFeatureIds &fids)
Unlinks the features with fids.
void deleteFeature(QgsFeatureId fid=QgsFeatureId())
Delete a feature with given fid.
QgsFeature feature() const
Returns the widget's current feature If the widget is in multiedit mode only the first is returned.
bool multiEditModeActive() const
Returns true if editing multiple features at a time.
void saveEdits()
Saves the current modifications in the relation.
void unlinkFeature(QgsFeatureId fid=QgsFeatureId())
Unlinks a feature with given fid.
void duplicateFeatures(const QgsFeatureIds &fids)
Duplicates features.
A menu that is populated automatically with the actions defined for a given layer.
static QIcon getThemeIcon(const QString &name, const QColor &fillColor=QColor(), const QColor &strokeColor=QColor())
Helper to get a theme icon.
Contains context information for attribute editor widgets.
QgsMapCanvas * mapCanvas() const
Returns the associated map canvas (e.g.
QgsAdvancedDigitizingDockWidget * cadDockWidget() const
Returns the associated CAD dock widget (e.g.
void setParentFormFeature(const QgsFeature &feature)
Sets the feature of the currently edited parent form.
This widget is used to show the attributes of a set of features of a QgsVectorLayer.
Definition qgsdualview.h:49
void showContextMenuExternally(QgsActionMenu *menu, QgsFeatureId fid)
Emitted when selecting context menu on the feature list to create the context menu individually.
ViewMode
The view modes, in which this widget can present information.
Definition qgsdualview.h:63
@ AttributeTable
Shows the features and attributes in a table layout.
Definition qgsdualview.h:68
@ AttributeEditor
Show a list of the features, where one can be chosen and the according attribute dialog will be prese...
Definition qgsdualview.h:75
A generic dialog for building expression strings.
QgsExpressionBuilderWidget * expressionBuilder()
The builder widget that is used by the dialog.
QString expressionText()
Gets the expression string that has been set in the expression area.
static std::vector< std::unique_ptr< QgsExpressionContextScope > > globalProjectLayerScopes(const QgsMapLayer *layer)
Creates a list of three scopes: global, layer's project and layer.
Expression contexts are used to encapsulate the parameters around which a QgsExpression should be eva...
static bool attemptReduceToInClause(const QStringList &expressions, QString &result)
Attempts to reduce a list of expressions to a single "field IN (val1, val2, ... )" type expression.
bool nextFeature(QgsFeature &f)
Fetch next feature and stores in f, returns true on success.
Wraps a request for features to a vector layer (or directly its vector data provider).
QgsFeatureRequest & setFilterExpression(const QString &expression)
Set the filter expression.
The feature class encapsulates a single feature including its unique ID, geometry and a list of field...
Definition qgsfeature.h:60
QgsFeatureId id
Definition qgsfeature.h:63
Is an interface class to abstract feature selection handling.
void selectionChanged(const QgsFeatureIds &selected, const QgsFeatureIds &deselected, bool clearAndSelect)
Emitted when selection was changed.
static QIcon iconForLayer(const QgsMapLayer *layer)
Returns the icon corresponding to a specified map layer.
static void warning(const QString &msg)
Goes to qWarning.
Map canvas is a class for displaying all GIS data types on a canvas.
void unsetMapTool(QgsMapTool *mapTool)
Unset the current map tool or last non zoom tool.
void setMapTool(QgsMapTool *mapTool, bool clean=false)
Sets the map tool currently being used on the canvas.
QString name
Definition qgsmaplayer.h:88
void editingStopped()
Emitted when edited changes have been successfully written to the data provider.
void editingStarted()
Emitted when editing on this layer has started.
void digitizingCanceled()
Emitted when the digitizing process was interrupted by the user.
void digitizingCompleted(const QgsFeature &feature)
Emitted whenever the digitizing has been successfully completed.
Abstract base class for all map tools.
Definition qgsmaptool.h:74
void deactivated()
Emitted when the map tool is deactivated.
static QgsMessageBarItem * createMessage(const QString &text, QWidget *parent=nullptr)
Creates message bar item widget containing a message text to be displayed on the bar.
Creates a new configuration widget for the relation editor widget.
QVariantMap config() override
Create a configuration from the current GUI state.
void setConfig(const QVariantMap &config) override
Update the configuration widget to represent the given configuration.
QgsRelationEditorConfigWidget(const QgsRelation &relation, QWidget *parent)
Create a new configuration widget.
void mEditExpression_clicked()
Opens an expression dialog and sets its value as filter expression for the linking dialog.
QString type() const override
Returns the machine readable identifier name of this widget type.
QString name() const override
Returns the human readable identifier name of this widget type.
QgsAbstractRelationEditorConfigWidget * configWidget(const QgsRelation &relation, QWidget *parent) const override
Override this in your implementation.
QgsAbstractRelationEditorWidget * create(const QVariantMap &config, QWidget *parent=nullptr) const override
Override this in your implementation.
The default relation widget in QGIS.
Q_DECL_DEPRECATED void duplicateFeature()
Duplicates a feature.
void zoomToSelectedFeatures()
Zooms to the selected features.
Button
Possible buttons shown in the relation editor.
@ ZoomToChildFeature
Zoom to child feature.
@ DeleteChildFeature
Delete child feature button.
@ DuplicateChildFeature
Duplicate child feature.
@ SaveChildEdits
Save child edits button.
@ AddChildFeature
Add child feature (as in some projects we only want to allow linking/unlinking existing features).
void beforeSetRelationFeature(const QgsRelation &newRelation, const QgsFeature &newFeature) override
A hook called right before setRelationFeature() is executed.
void parentFormValueChanged(const QString &attribute, const QVariant &newValue) override
void setEditorContext(const QgsAttributeEditorContext &context) override
Sets the editor context.
QgsIFeatureSelectionManager * featureSelectionManager()
The feature selection manager is responsible for the selected features which are currently being edit...
void updateUi() override
A hook called every time the state of the relation editor widget has changed via calling its set* met...
void unlinkSelectedFeatures()
Unlinks the selected features from the relation.
void setViewMode(QgsDualView::ViewMode mode)
Define the view mode for the dual view.
void setVisibleButtons(const Buttons &buttons)
Defines the buttons which are shown.
void duplicateSelectedFeatures()
Duplicates the selected features.
void afterSetRelationFeature() override
A hook called right after setRelationFeature() is executed, but before updateUi() is called.
QgsRelationEditorWidget(const QVariantMap &config, QWidget *parent=nullptr)
Constructor.
QVariantMap config() const override
Returns the current configuration.
void setConfig(const QVariantMap &config) override
Defines the current configuration.
void beforeSetRelations(const QgsRelation &newRelation, const QgsRelation &newNmRelation) override
A hook called right before setRelations() is executed.
void afterSetRelations() override
A hook called right after setRelations() is executed, but before updateUi() is called.
void deleteSelectedFeatures()
Deletes the currently selected features.
Represents a relationship between two vector layers.
Definition qgsrelation.h:42
QgsVectorLayer * referencedLayer
Definition qgsrelation.h:50
QgsVectorLayer * referencingLayer
Definition qgsrelation.h:47
QgsFeatureRequest getRelatedFeaturesRequest(const QgsFeature &feature) const
Creates a request to return all the features on the referencing (child) layer which have a foreign ke...
static QString getFeatureDisplayString(const QgsVectorLayer *layer, const QgsFeature &feature)
Returns a descriptive string for a feature, suitable for displaying to the user.
Represents a vector layer which manages a vector based dataset.
bool isEditable() const final
Returns true if the provider is in editing mode.
bool isSpatial() const final
Returns true if this is a geometry layer and false in case of NoGeometry (table only) or UnknownGeome...
Q_INVOKABLE const QgsFeatureIds & selectedFeatureIds() const
Returns a list of the selected features IDs in this layer.
Q_INVOKABLE Qgis::GeometryType geometryType() const
Returns point, line or polygon.
void selectionChanged(const QgsFeatureIds &selected, const QgsFeatureIds &deselected, bool clearAndSelect)
Emitted when selection was changed.
Q_INVOKABLE QgsFeature getFeature(QgsFeatureId fid) const
Queries the layer for the feature with the given id.
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
QString qgsFlagValueToKeys(const T &value, bool *returnOk=nullptr)
Returns the value for the given keys of a flag.
Definition qgis.h:8143
T qgsFlagKeysToValue(const QString &keys, const T &defaultValue, bool tryValueAsKey=true, bool *returnOk=nullptr)
Returns the value corresponding to the given keys of a flag.
Definition qgis.h:8172
QSet< QgsFeatureId > QgsFeatureIds
qint64 QgsFeatureId
64 bit feature ids negative numbers are used for uncommitted/newly added features
constexpr QObjectUniquePtr< Tp > make_qobject_unique(Args &&...args)
Create an object owned by a QObjectUniquePtr.