const QgsFeature* QgsActionMenu::feature() { if ( !mFeature || !mFeature->isValid() ) { QgsFeature* feat = new QgsFeature(); if ( mActions->layer()->getFeatures( QgsFeatureRequest( mFeatureId ) ).nextFeature( *feat ) ) { mFeature = feat; mOwnsFeature = true; } else { delete feat; } } return mFeature; }
QgsFeature QgsRelationReferenceWidget::referencedFeature() { QgsFeature f; if ( mReferencedLayer ) { QgsFeatureId fid; if ( mReadOnlySelector ) { fid = mFeatureId; } else { fid = mComboBox->itemData( mComboBox->currentIndex() ).value<QgsFeatureId>(); } mReferencedLayer->getFeatures( QgsFeatureRequest().setFilterFid( fid ) ).nextFeature( f ); } return f; }
void QgsSelectedFeature::updateGeometry( const QgsGeometry *geom ) { delete mGeometry; if ( !geom ) { QgsFeature f; mVlayer->getFeatures( QgsFeatureRequest().setFilterFid( mFeatureId ) ).nextFeature( f ); if ( f.hasGeometry() ) mGeometry = new QgsGeometry( f.geometry() ); else mGeometry = new QgsGeometry(); } else { mGeometry = new QgsGeometry( *geom ); } }
QgsFeature QgsRelationReferenceWidget::referencedFeature() const { QgsFeature f; if ( mReferencedLayer ) { QgsFeatureId fid; if ( mReadOnlySelector ) { fid = mFeature.id(); } else { fid = mComboBox->currentData( QgsAttributeTableModel::FeatureIdRole ).value<QgsFeatureId>(); } mReferencedLayer->getFeatures( QgsFeatureRequest().setFilterFid( fid ) ).nextFeature( f ); } return f; }
QgsFeature QgsRelationReferenceWidget::referencedFeature() const { QgsFeature f; if ( mReferencedLayer ) { QgsFeatureRequest request; if ( mReadOnlySelector ) { request = QgsFeatureRequest().setFilterFid( mFeature.id() ); } else { request = mComboBox->currentFeatureRequest(); } mReferencedLayer->getFeatures( request ).nextFeature( f ); } return f; }
int QgsVectorLayerEditUtils::translateFeature( QgsFeatureId featureId, double dx, double dy ) { if ( !mLayer->isSpatial() ) return 1; QgsFeature f; if ( !mLayer->getFeatures( QgsFeatureRequest().setFilterFid( featureId ).setSubsetOfAttributes( QgsAttributeList() ) ).nextFeature( f ) || !f.hasGeometry() ) return 1; //geometry not found QgsGeometry geometry = f.geometry(); int errorCode = geometry.translate( dx, dy ); if ( errorCode == 0 ) { mLayer->editBuffer()->changeGeometry( featureId, geometry ); } return errorCode; }
bool QgsLayoutAtlas::prepareForFeature( const int featureI ) { if ( !mCoverageLayer ) { return false; } if ( mFeatureIds.isEmpty() ) { emit messagePushed( tr( "No matching atlas features" ) ); return false; } if ( featureI >= mFeatureIds.size() ) { return false; } mCurrentFeatureNo = featureI; // retrieve the next feature, based on its id if ( !mCoverageLayer->getFeatures( QgsFeatureRequest().setFilterFid( mFeatureIds[ featureI ].first ) ).nextFeature( mCurrentFeature ) ) return false; mLayout->reportContext().blockSignals( true ); // setFeature emits changed, we don't want 2 signals mLayout->reportContext().setLayer( mCoverageLayer.get() ); mLayout->reportContext().blockSignals( false ); mLayout->reportContext().setFeature( mCurrentFeature ); // must come after we've set the report context feature, or the expression context will have an outdated atlas feature QgsExpressionContext expressionContext = createExpressionContext(); // generate filename for current feature if ( !evalFeatureFilename( expressionContext ) ) { //error evaluating filename return false; } emit featureChanged( mCurrentFeature ); emit messagePushed( QString( tr( "Atlas feature %1 of %2" ) ).arg( featureI + 1 ).arg( mFeatureIds.size() ) ); return mCurrentFeature.isValid(); }
QgsGeometry* QgsTransectSample::findBaselineGeometry( QVariant strataId ) { if ( !mBaselineLayer ) { return 0; } QgsFeatureIterator baseLineIt = mBaselineLayer->getFeatures( QgsFeatureRequest().setSubsetOfAttributes( QStringList( mBaselineStrataId ), mBaselineLayer->pendingFields() ) ); QgsFeature fet; while ( baseLineIt.nextFeature( fet ) ) //todo: cache this in case there are many baslines { if ( strataId == fet.attribute( mBaselineStrataId ) || mShareBaseline ) { Q_NOWARN_DEPRECATED_PUSH return fet.geometryAndOwnership(); Q_NOWARN_DEPRECATED_POP } }
void QgsSizeScaleWidget::computeFromLayerTriggered() { if ( !mLayer ) return; QgsExpression expression( mExpressionWidget->currentField() ); QgsExpressionContext context; context << QgsExpressionContextUtils::globalScope() << QgsExpressionContextUtils::projectScope() << QgsExpressionContextUtils::atlasScope( 0 ) << QgsExpressionContextUtils::layerScope( mLayer ); if ( ! expression.prepare( &context ) ) return; QStringList lst( expression.referencedColumns() ); QgsFeatureIterator fit = mLayer->getFeatures( QgsFeatureRequest().setFlags( expression.needsGeometry() ? QgsFeatureRequest::NoFlags : QgsFeatureRequest::NoGeometry ) .setSubsetOfAttributes( lst, mLayer->fields() ) ); // create list of non-null attribute values double min = DBL_MAX; double max = -DBL_MAX; QgsFeature f; while ( fit.nextFeature( f ) ) { bool ok; context.setFeature( f ); const double value = expression.evaluate( &context ).toDouble( &ok ); if ( ok ) { max = qMax( max, value ); min = qMin( min, value ); } } minValueSpinBox->setValue( min ); maxValueSpinBox->setValue( max ); updatePreview(); }
QgsGeometry QgsTransectSample::findBaselineGeometry( const QVariant& strataId ) { if ( !mBaselineLayer ) { return QgsGeometry(); } QgsFeatureIterator baseLineIt = mBaselineLayer->getFeatures( QgsFeatureRequest().setSubsetOfAttributes( QStringList( mBaselineStrataId ), mBaselineLayer->fields() ) ); QgsFeature fet; while ( baseLineIt.nextFeature( fet ) ) //todo: cache this in case there are many baslines { if ( strataId == fet.attribute( mBaselineStrataId ) || mShareBaseline ) { return fet.geometry(); } } return QgsGeometry(); }
bool QgsFeaturePool::get( const QgsFeatureId& id , QgsFeature& feature ) { QMutexLocker lock( &mLayerMutex ); QgsFeature* pfeature = mFeatureCache.object( id ); if ( pfeature == 0 ) { // Get new feature pfeature = new QgsFeature(); // TODO: avoid always querying all attributes (attribute values are needed when merging by attribute) if ( !mLayer->getFeatures( QgsFeatureRequest( id ) ).nextFeature( *pfeature ) ) { delete pfeature; return false; } mFeatureCache.insert( id, pfeature ); } feature = *pfeature; return true; }
void QgsAttributeTypeDialog::defaultExpressionChanged() { QString expression = mExpressionWidget->expression(); if ( expression.isEmpty() ) { mDefaultPreviewLabel->setText( QString() ); return; } QgsExpressionContext context = mLayer->createExpressionContext(); if ( !mPreviewFeature.isValid() ) { // get first feature QgsFeatureIterator it = mLayer->getFeatures( QgsFeatureRequest().setLimit( 1 ) ); it.nextFeature( mPreviewFeature ); } context.setFeature( mPreviewFeature ); QgsExpression exp = QgsExpression( expression ); exp.prepare( &context ); if ( exp.hasParserError() ) { mDefaultPreviewLabel->setText( "<i>" + exp.parserErrorString() + "</i>" ); return; } QVariant val = exp.evaluate( &context ); if ( exp.hasEvalError() ) { mDefaultPreviewLabel->setText( "<i>" + exp.evalErrorString() + "</i>" ); return; } QgsFieldFormatter *fieldFormatter = QgsApplication::fieldFormatterRegistry()->fieldFormatter( editorWidgetType() ); QString previewText = fieldFormatter->representValue( mLayer, mFieldIdx, editorWidgetConfig(), QVariant(), val ); mDefaultPreviewLabel->setText( "<i>" + previewText + "</i>" ); }
void QgsRubberSelectId::addFeature( QgsVectorLayer* lyr, QgsFeatureId fid ) { if ( mGeometryType != lyr->geometryType() ) { reset(); mGeometryType = lyr->geometryType(); mRubberBand->reset( lyr->geometryType() ); setStyle(); } QgsFeature feat; if ( !lyr->getFeatures( QgsFeatureRequest().setFilterFid( fid ).setSubsetOfAttributes( QgsAttributeList() ) ).nextFeature( feat ) ) { return; } if ( !feat.hasGeometry() ) { return; } mRubberBand->setToGeometry( feat.geometry(), lyr ); } // void QgsRubberSelectId::addFeature( QgsVectorLayer* mLayer, int Id )
void QgsOfflineEditing::applyFeaturesAdded( QgsVectorLayer* offlineLayer, QgsVectorLayer* remoteLayer, sqlite3* db, int layerId ) { QString sql = QString( "SELECT \"fid\" FROM 'log_added_features' WHERE \"layer_id\" = %1" ).arg( layerId ); QList<int> newFeatureIds = sqlQueryInts( db, sql ); // get new features from offline layer QgsFeatureList features; for ( int i = 0; i < newFeatureIds.size(); i++ ) { QgsFeature feature; if ( offlineLayer->getFeatures( QgsFeatureRequest().setFilterFid( newFeatureIds.at( i ) ) ).nextFeature( feature ) ) { features << feature; } } // copy features to remote layer emit progressModeSet( QgsOfflineEditing::AddFeatures, features.size() ); int i = 1; int newAttrsCount = remoteLayer->pendingFields().count(); for ( QgsFeatureList::iterator it = features.begin(); it != features.end(); ++it ) { QgsFeature f = *it; // NOTE: Spatialite provider ignores position of geometry column // restore gap in QgsAttributeMap if geometry column is not last (WORKAROUND) QMap<int, int> attrLookup = attributeLookup( offlineLayer, remoteLayer ); QgsAttributes newAttrs( newAttrsCount ); QgsAttributes attrs = f.attributes(); for ( int it = 0; it < attrs.count(); ++it ) { newAttrs[ attrLookup[ it ] ] = attrs[ it ]; } f.setAttributes( newAttrs ); remoteLayer->addFeature( f, false ); emit progressUpdated( i++ ); } }
QgsFeatureIterator QgsVectorLayerUtils::getValuesIterator( const QgsVectorLayer *layer, const QString &fieldOrExpression, bool &ok, bool selectedOnly ) { std::unique_ptr<QgsExpression> expression; QgsExpressionContext context; int attrNum = layer->fields().lookupField( fieldOrExpression ); if ( attrNum == -1 ) { // try to use expression expression.reset( new QgsExpression( fieldOrExpression ) ); context.appendScopes( QgsExpressionContextUtils::globalProjectLayerScopes( layer ) ); if ( expression->hasParserError() || !expression->prepare( &context ) ) { ok = false; return QgsFeatureIterator(); } } QSet<QString> lst; if ( !expression ) lst.insert( fieldOrExpression ); else lst = expression->referencedColumns(); QgsFeatureRequest request = QgsFeatureRequest() .setFlags( ( expression && expression->needsGeometry() ) ? QgsFeatureRequest::NoFlags : QgsFeatureRequest::NoGeometry ) .setSubsetOfAttributes( lst, layer->fields() ); ok = true; if ( !selectedOnly ) { return layer->getFeatures( request ); } else { return layer->getSelectedFeatures( request ); } }
void QgsOverlayAnalyzer::intersectFeature( QgsFeature& f, QgsVectorFileWriter* vfw, QgsVectorLayer* vl, QgsSpatialIndex* index ) { if ( !f.hasGeometry() ) { return; } QgsGeometry featureGeometry = f.geometry(); QgsGeometry intersectGeometry; QgsFeature overlayFeature; QList<QgsFeatureId> intersects; intersects = index->intersects( featureGeometry.boundingBox() ); QList<QgsFeatureId>::const_iterator it = intersects.constBegin(); QgsFeature outFeature; for ( ; it != intersects.constEnd(); ++it ) { if ( !vl->getFeatures( QgsFeatureRequest().setFilterFid( *it ) ).nextFeature( overlayFeature ) ) { continue; } if ( featureGeometry.intersects( overlayFeature.geometry() ) ) { intersectGeometry = featureGeometry.intersection( overlayFeature.geometry() ); outFeature.setGeometry( intersectGeometry ); QgsAttributes attributesA = f.attributes(); QgsAttributes attributesB = overlayFeature.attributes(); combineAttributeMaps( attributesA, attributesB ); outFeature.setAttributes( attributesA ); //add it to vector file writer if ( vfw ) { vfw->addFeature( outFeature ); } } } }
bool QgsVectorLayerEditUtils::moveVertex( const QgsPointV2& p, QgsFeatureId atFeatureId, int atVertex ) { if ( !L->hasGeometryType() ) return false; QgsGeometry geometry; if ( !cache()->geometry( atFeatureId, geometry ) ) { // it's not in cache: let's fetch it from layer QgsFeature f; if ( !L->getFeatures( QgsFeatureRequest().setFilterFid( atFeatureId ).setSubsetOfAttributes( QgsAttributeList() ) ).nextFeature( f ) || !f.constGeometry() ) return false; // geometry not found geometry = *f.constGeometry(); } geometry.moveVertex( p, atVertex ); L->editBuffer()->changeGeometry( atFeatureId, &geometry ); return true; }
bool QgsVectorLayerEditUtils::insertVertex( double x, double y, QgsFeatureId atFeatureId, int beforeVertex ) { if ( !L->hasGeometryType() ) return false; QgsGeometry geometry; if ( !cache()->geometry( atFeatureId, geometry ) ) { // it's not in cache: let's fetch it from layer QgsFeature f; if ( !L->getFeatures( QgsFeatureRequest().setFilterFid( atFeatureId ).setSubsetOfAttributes( QgsAttributeList() ) ).nextFeature( f ) || !f.hasGeometry() ) return false; // geometry not found geometry = f.geometry(); } geometry.insertVertex( x, y, beforeVertex ); L->editBuffer()->changeGeometry( atFeatureId, geometry ); return true; }
void QgsVectorDataProvider::uniqueValues( int index, QList<QVariant> &values, int limit ) { QgsFeature f; QgsAttributeList keys; keys.append( index ); QgsFeatureIterator fi = getFeatures( QgsFeatureRequest().setSubsetOfAttributes( keys ) ); QSet<QString> set; values.clear(); while ( fi.nextFeature( f ) ) { if ( !set.contains( f.attribute( index ).toString() ) ) { values.append( f.attribute( index ) ); set.insert( f.attribute( index ).toString() ); } if ( limit >= 0 && values.size() >= limit ) break; } }
void QgsVectorLayerRenderer::prepareLabeling( QgsVectorLayer* layer, QStringList& attributeNames ) { if ( !mContext.labelingEngine() ) return; if ( mContext.labelingEngine()->prepareLayer( layer, attributeNames, mContext ) ) { mLabeling = true; QgsPalLayerSettings& palyr = mContext.labelingEngine()->layer( mLayerID ); Q_UNUSED( palyr ); #if 0 // TODO: limit of labels, font not found // see if feature count limit is set for labeling if ( palyr.limitNumLabels && palyr.maxNumLabels > 0 ) { QgsFeatureIterator fit = getFeatures( QgsFeatureRequest() .setFilterRect( mContext.extent() ) .setSubsetOfAttributes( QgsAttributeList() ) ); // total number of features that may be labeled QgsFeature f; int nFeatsToLabel = 0; while ( fit.nextFeature( f ) ) { nFeatsToLabel++; } palyr.mFeaturesToLabel = nFeatsToLabel; } // notify user about any font substitution if ( !palyr.mTextFontFound && !mLabelFontNotFoundNotified ) { emit labelingFontNotFound( this, palyr.mTextFontFamily ); mLabelFontNotFoundNotified = true; } #endif } }
bool QgsMapToolLabel::dataDefinedShowHide( QgsVectorLayer* vlayer, const QgsFeatureId &featureId, int& show, bool& showSuccess, int& showCol ) const { showSuccess = false; if ( !vlayer ) { return false; } if ( !layerCanShowHide( vlayer, showCol ) ) { return false; } QgsFeature f; if ( !vlayer->getFeatures( QgsFeatureRequest().setFilterFid( featureId ).setFlags( QgsFeatureRequest::NoGeometry ) ).nextFeature( f ) ) { return false; } show = f.attribute( showCol ).toInt( &showSuccess ); return true; }
bool QgsMapToolLabel::currentLabelDataDefinedPosition( double &x, bool &xSuccess, double &y, bool &ySuccess, int &xCol, int &yCol ) const { QgsVectorLayer *vlayer = mCurrentLabel.layer; QgsFeatureId featureId = mCurrentLabel.pos.featureId; xSuccess = false; ySuccess = false; if ( !vlayer ) { return false; } if ( mCurrentLabel.pos.isDiagram ) { if ( !diagramMoveable( vlayer, xCol, yCol ) ) { return false; } } else if ( !labelMoveable( vlayer, mCurrentLabel.settings, xCol, yCol ) ) { return false; } QgsFeature f; if ( !vlayer->getFeatures( QgsFeatureRequest().setFilterFid( featureId ).setFlags( QgsFeatureRequest::NoGeometry ) ).nextFeature( f ) ) { return false; } QgsAttributes attributes = f.attributes(); if ( !attributes.at( xCol ).isNull() ) x = attributes.at( xCol ).toDouble( &xSuccess ); if ( !attributes.at( yCol ).isNull() ) y = attributes.at( yCol ).toDouble( &ySuccess ); return true; }
void QgsRelationReferenceWidget::init() { if ( !mReadOnlySelector && mComboBox->count() == 0 && mReferencedLayer ) { QApplication::setOverrideCursor( Qt::WaitCursor ); if ( mAllowNull ) { const QString nullValue = QSettings().value( "qgis/nullValue", "NULL" ).toString(); mComboBox->addItem( tr( "%1 (no selection)" ).arg( nullValue ), QVariant( QVariant::Int ) ); mComboBox->setItemData( 0, QColor( Qt::gray ), Qt::ForegroundRole ); } QgsExpression exp( mReferencedLayer->displayExpression() ); QStringList attrs = exp.referencedColumns(); attrs << mRelation.fieldPairs().first().second; QgsFeatureIterator fit = mReferencedLayer->getFeatures( QgsFeatureRequest().setFlags( QgsFeatureRequest::NoGeometry ).setSubsetOfAttributes( attrs, mReferencedLayer->pendingFields() ) ); exp.prepare( mReferencedLayer->pendingFields() ); QgsFeature f; while ( fit.nextFeature( f ) ) { QString txt = exp.evaluate( &f ).toString(); mComboBox->addItem( txt, f.id() ); if ( f.attribute( mFkeyFieldIdx ) == mForeignKey ) mComboBox->setCurrentIndex( mComboBox->count() - 1 ); mFidFkMap.insert( f.id(), f.attribute( mFkeyFieldIdx ) ); } // Only connect after iterating, to have only one iterator on the referenced table at once connect( mComboBox, SIGNAL( activated( int ) ), this, SLOT( comboReferenceChanged( int ) ) ); QApplication::restoreOverrideCursor(); }
int QgsVectorLayerEditUtils::addRing( const QList<QgsPoint>& ring ) { if ( !L->hasGeometryType() ) return 5; int addRingReturnCode = 5; //default: return code for 'ring not inserted' double xMin, yMin, xMax, yMax; QgsRectangle bBox; if ( boundingBoxFromPointList( ring, xMin, yMin, xMax, yMax ) == 0 ) { bBox.setXMinimum( xMin ); bBox.setYMinimum( yMin ); bBox.setXMaximum( xMax ); bBox.setYMaximum( yMax ); } else { return 3; //ring not valid } QgsFeatureIterator fit = L->getFeatures( QgsFeatureRequest().setFilterRect( bBox ).setFlags( QgsFeatureRequest::ExactIntersect ) ); QgsFeature f; while ( fit.nextFeature( f ) ) { addRingReturnCode = f.geometry()->addRing( ring ); if ( addRingReturnCode == 0 ) { L->editBuffer()->changeGeometry( f.id(), f.geometry() ); //setModified( true, true ); break; } } return addRingReturnCode; }
QString QgsMapTip::fetchFeature( QgsMapLayer *layer, QgsPoint &mapPosition, QgsMapCanvas *mapCanvas ) { QgsVectorLayer *vlayer = qobject_cast<QgsVectorLayer *>( layer ); if ( !vlayer ) return QString(); double searchRadius = QgsMapTool::searchRadiusMU( mapCanvas ); QgsRectangle r; r.setXMinimum( mapPosition.x() - searchRadius ); r.setYMinimum( mapPosition.y() - searchRadius ); r.setXMaximum( mapPosition.x() + searchRadius ); r.setYMaximum( mapPosition.y() + searchRadius ); r = mapCanvas->mapSettings().mapToLayerCoordinates( layer, r ); QgsFeature feature; if ( !vlayer->getFeatures( QgsFeatureRequest().setFilterRect( r ).setFlags( QgsFeatureRequest::ExactIntersect ) ).nextFeature( feature ) ) return QString(); QgsExpressionContext context( QgsExpressionContextUtils::globalProjectLayerScopes( vlayer ) ); if ( mapCanvas ) context.appendScope( QgsExpressionContextUtils::mapSettingsScope( mapCanvas->mapSettings() ) ); context.setFeature( feature ); QString mapTip = vlayer->mapTipTemplate(); if ( !mapTip.isEmpty() ) { return QgsExpression::replaceExpressionText( mapTip, &context ); } else { QgsExpression exp( vlayer->displayExpression() ); return exp.evaluate( &context ).toString(); } }
int QgsVectorLayerEditUtils::addPart( QgsCurveV2* ring, QgsFeatureId featureId ) { if ( !L->hasGeometryType() ) return 6; QgsGeometry geometry; bool firstPart = false; if ( !cache()->geometry( featureId, geometry ) ) // maybe it's in cache { // it's not in cache: let's fetch it from layer QgsFeature f; if ( !L->getFeatures( QgsFeatureRequest().setFilterFid( featureId ).setSubsetOfAttributes( QgsAttributeList() ) ).nextFeature( f ) ) return 6; //not found if ( !f.constGeometry() || f.constGeometry()->isEmpty() ) { //no existing geometry, so adding first part to null geometry firstPart = true; } else { geometry = *f.geometry(); } } int errorCode = geometry.addPart( ring, L->geometryType() ); if ( errorCode == 0 ) { if ( firstPart && QgsWKBTypes::isSingleType( QGis::fromOldWkbType( L->wkbType() ) ) && L->dataProvider()->doesStrictFeatureTypeCheck() ) { //convert back to single part if required by layer geometry.convertToSingleType(); } L->editBuffer()->changeGeometry( featureId, &geometry ); } return errorCode; }
/** * Selection routine called by the mouse release event * @param thePoint = QgsPoint representing the x, y coordinates of the mouse release event */ void eVisEventIdTool::select( QgsPoint thePoint ) { if ( 0 == mCanvas ) return; QgsVectorLayer* myLayer = ( QgsVectorLayer* )mCanvas->currentLayer( ); // create the search rectangle. this was modeled after the QgsMapIdentifyTool in core QGIS application double searchWidth = mCanvas->extent( ).width( ) * (( double )QGis::DEFAULT_IDENTIFY_RADIUS / 100.0 ); QgsRectangle myRectangle; myRectangle.setXMinimum( thePoint.x( ) - searchWidth ); myRectangle.setXMaximum( thePoint.x( ) + searchWidth ); myRectangle.setYMinimum( thePoint.y( ) - searchWidth ); myRectangle.setYMaximum( thePoint.y( ) + searchWidth ); //Transform rectange to map coordinates myRectangle = toLayerCoordinates( myLayer, myRectangle ); //Rather than add to the current selection, clear all selected features myLayer->removeSelection( false ); //select features QgsFeatureIterator fit = myLayer->getFeatures( QgsFeatureRequest().setFilterRect( myRectangle ).setFlags( QgsFeatureRequest::ExactIntersect ).setSubsetOfAttributes( QgsAttributeList() ) ); QgsFeature f; QgsFeatureIds newSelectedFeatures; while ( fit.nextFeature( f ) ) { newSelectedFeatures.insert( f.id() ); } myLayer->setSelectedFeatures( newSelectedFeatures ); //Launch a new event browser to view selected features mBrowser = new eVisGenericEventBrowserGui( mCanvas, mCanvas, NULL ); mBrowser->setAttribute( Qt::WA_DeleteOnClose ); }
void QgsMapToolDeleteRing::canvasReleaseEvent( QgsMapMouseEvent *e ) { Q_UNUSED( e ); delete mRubberBand; mRubberBand = nullptr; if ( mPressedFid == -1 ) return; QgsFeature f; vlayer->getFeatures( QgsFeatureRequest().setFilterFid( mPressedFid ) ).nextFeature( f ); QgsGeometry g = f.geometry(); if ( g.deleteRing( mPressedRingNum, mPressedPartNum ) ) { vlayer->beginEditCommand( tr( "Ring deleted" ) ); vlayer->changeGeometry( mPressedFid, g ); vlayer->endEditCommand(); vlayer->triggerRepaint(); } }
int QgsVectorLayerEditUtils::addPart( const QList<QgsPoint> &points, QgsFeatureId featureId ) { if ( !L->hasGeometryType() ) return 6; QgsGeometry geometry; if ( !cache()->geometry( featureId, geometry ) ) // maybe it's in cache { // it's not in cache: let's fetch it from layer QgsFeature f; if ( !L->getFeatures( QgsFeatureRequest().setFilterFid( featureId ).setSubsetOfAttributes( QgsAttributeList() ) ).nextFeature( f ) || !f.geometry() ) return 6; //geometry not found geometry = *f.geometry(); } int errorCode = geometry.addPart( points, L->geometryType() ); if ( errorCode == 0 ) { L->editBuffer()->changeGeometry( featureId, &geometry ); } return errorCode; }
int QgsVectorLayerEditUtils::translateFeature( QgsFeatureId featureId, double dx, double dy ) { if ( !L->hasGeometryType() ) return 1; QgsGeometry geometry; if ( !cache()->geometry( featureId, geometry ) ) // maybe it's in cache { // it's not in cache: let's fetch it from layer QgsFeature f; if ( !L->getFeatures( QgsFeatureRequest().setFilterFid( featureId ).setSubsetOfAttributes( QgsAttributeList() ) ).nextFeature( f ) || !f.constGeometry() ) return 1; //geometry not found geometry = *f.constGeometry(); } int errorCode = geometry.translate( dx, dy ); if ( errorCode == 0 ) { L->editBuffer()->changeGeometry( featureId, &geometry ); } return errorCode; }