bool QgsMapToolPinLabels::pinUnpinCurrentDiagram( bool pin )
{
// skip diagrams
if ( ! mCurrentLabel.pos.isDiagram )
return false;
// verify attribute table has x, y fields mapped
int xCol, yCol;
double xPosOrig, yPosOrig;
bool xSuccess, ySuccess;
if ( !currentLabelDataDefinedPosition( xPosOrig, xSuccess, yPosOrig, ySuccess, xCol, yCol ) )
return false;
// edit attribute table
QgsVectorLayer *vlayer = mCurrentLabel.layer;
int fid = mCurrentLabel.pos.featureId;
bool writeFailed = false;
QString labelText = currentLabelText( 24 );
if ( pin )
{
QgsPointXY referencePoint = mCurrentLabel.pos.labelRect.center();
double labelX = referencePoint.x();
double labelY = referencePoint.y();
// transform back to layer crs
QgsPointXY transformedPoint = mCanvas->mapSettings().mapToLayerCoordinates( vlayer, referencePoint );
labelX = transformedPoint.x();
labelY = transformedPoint.y();
vlayer->beginEditCommand( tr( "Pinned diagram" ) + QStringLiteral( " '%1'" ).arg( labelText ) );
writeFailed = !vlayer->changeAttributeValue( fid, xCol, labelX );
if ( !vlayer->changeAttributeValue( fid, yCol, labelY ) )
writeFailed = true;
vlayer->endEditCommand();
}
else
{
vlayer->beginEditCommand( tr( "Unpinned diagram" ) + QStringLiteral( " '%1'" ).arg( labelText ) );
writeFailed = !vlayer->changeAttributeValue( fid, xCol, QVariant( QString() ) );
if ( !vlayer->changeAttributeValue( fid, yCol, QVariant( QString() ) ) )
writeFailed = true;
vlayer->endEditCommand();
}
return !writeFailed;
}
void QgsMapToolChangeLabelProperties::canvasReleaseEvent( QMouseEvent * e )
{
QgsVectorLayer* vlayer = currentLayer();
if ( mLabelRubberBand && mCanvas && vlayer )
{
QgsLabelPropertyDialog d( mCurrentLabelPos.layerID, mCurrentLabelPos.featureId, mCanvas->mapRenderer() );
if ( d.exec() == QDialog::Accepted )
{
const QgsAttributeMap& changes = d.changedProperties();
if ( changes.size() > 0 )
{
vlayer->beginEditCommand( tr( "Label properties changed" ) );
QgsAttributeMap::const_iterator changeIt = changes.constBegin();
for ( ; changeIt != changes.constEnd(); ++changeIt )
{
vlayer->changeAttributeValue( mCurrentLabelPos.featureId, changeIt.key(), changeIt.value(), false );
}
vlayer->endEditCommand();
mCanvas->refresh();
}
}
deleteRubberBands();
}
}
void QgsMapToolChangeLabelProperties::canvasReleaseEvent( QMouseEvent *e )
{
Q_UNUSED( e );
QgsVectorLayer* vlayer = currentLayer();
if ( mLabelRubberBand && mCanvas && vlayer )
{
QString labeltext = QString(); // NULL QString signifies no expression
bool settingsOk;
QgsPalLayerSettings& labelSettings = currentLabelSettings( &settingsOk );
if ( settingsOk && labelSettings.isExpression )
{
labeltext = mCurrentLabelPos.labelText;
}
QgsLabelPropertyDialog d( mCurrentLabelPos.layerID, mCurrentLabelPos.featureId, mCurrentLabelPos.labelFont, labeltext, 0 );
if ( d.exec() == QDialog::Accepted )
{
const QgsAttributeMap& changes = d.changedProperties();
if ( changes.size() > 0 )
{
vlayer->beginEditCommand( tr( "Changed properties for label" ) + QString( " '%1'" ).arg( currentLabelText( 24 ) ) );
QgsAttributeMap::const_iterator changeIt = changes.constBegin();
for ( ; changeIt != changes.constEnd(); ++changeIt )
{
vlayer->changeAttributeValue( mCurrentLabelPos.featureId, changeIt.key(), changeIt.value() );
}
vlayer->endEditCommand();
mCanvas->refresh();
}
}
deleteRubberBands();
}
}
void QgsAttributeTableDelegate::setModelData( QWidget *editor, QAbstractItemModel *model, const QModelIndex &index ) const
{
QgsVectorLayer *vl = layer( model );
if ( !vl )
return;
int fieldIdx = model->data( index, QgsAttributeTableModel::FieldIndexRole ).toInt();
QgsFeatureId fid = model->data( index, QgsAttributeTableModel::FeatureIdRole ).toLongLong();
QVariant oldValue = model->data( index, Qt::EditRole );
QVariant newValue;
QgsEditorWidgetWrapper *eww = QgsEditorWidgetWrapper::fromWidget( editor );
if ( !eww )
return;
newValue = eww->value();
if ( ( oldValue != newValue && newValue.isValid() ) || oldValue.isNull() != newValue.isNull() )
{
// This fixes https://issues.qgis.org/issues/16492
QgsFeatureRequest request( fid );
request.setFlags( QgsFeatureRequest::NoGeometry );
request.setSubsetOfAttributes( QgsAttributeList() );
QgsFeature feature;
vl->getFeatures( request ).nextFeature( feature );
if ( feature.isValid() )
{
vl->beginEditCommand( tr( "Attribute changed" ) );
vl->changeAttributeValue( fid, fieldIdx, newValue, oldValue );
vl->endEditCommand();
}
}
}
void QgsAttributeTableDelegate::setModelData( QWidget *editor, QAbstractItemModel *model, const QModelIndex &index ) const
{
QgsVectorLayer *vl = layer( model );
if ( vl == NULL )
return;
int fieldIdx = model->data( index, QgsAttributeTableModel::FieldIndexRole ).toInt();
QgsFeatureId fid = model->data( index, QgsAttributeTableModel::FeatureIdRole ).toInt();
QVariant value;
if ( !QgsAttributeEditor::retrieveValue( editor, vl, fieldIdx, value ) )
return;
vl->beginEditCommand( tr( "Attribute changed" ) );
vl->changeAttributeValue( fid, fieldIdx, value, true );
vl->endEditCommand();
}
bool QgsMapToolShowHideLabels::showHide( const QgsLabelPosition &pos, bool show )
{
LabelDetails details = LabelDetails( pos );
if ( !details.valid )
return false;
QgsVectorLayer *vlayer = details.layer;
if ( !vlayer )
return false;
int showCol = -1;
if ( pos.isDiagram )
{
if ( !diagramCanShowHide( vlayer, showCol ) )
{
QgsDiagramIndexes indexes;
createAuxiliaryFields( details, indexes );
showCol = indexes[ QgsDiagramLayerSettings::Show ];
}
}
else
{
if ( !labelCanShowHide( vlayer, showCol ) )
{
QgsPalIndexes indexes;
createAuxiliaryFields( details, indexes );
showCol = indexes[ QgsPalLayerSettings::Show ];
}
}
if ( showCol >= 0 )
{
int showVal = show ? 1 : 0;
vlayer->changeAttributeValue( pos.featureId, showCol, showVal );
return true;
}
return false;
}
void QgsMapToolChangeLabelProperties::applyChanges( const QgsAttributeMap& changes )
{
QgsVectorLayer* vlayer = mCurrentLabel.layer;
if ( !vlayer )
return;
if ( !changes.isEmpty() )
{
vlayer->beginEditCommand( tr( "Changed properties for label" ) + QStringLiteral( " '%1'" ).arg( currentLabelText( 24 ) ) );
QgsAttributeMap::const_iterator changeIt = changes.constBegin();
for ( ; changeIt != changes.constEnd(); ++changeIt )
{
vlayer->changeAttributeValue( mCurrentLabel.pos.featureId, changeIt.key(), changeIt.value() );
}
vlayer->endEditCommand();
vlayer->triggerRepaint();
}
}
void QgsMapToolRotateLabel::canvasReleaseEvent( QgsMapMouseEvent* e )
{
Q_UNUSED( e );
if ( !mLabelRubberBand ) //no rubber band created (most likely because the current label cannot be rotated )
{
return;
}
deleteRubberBands();
delete mRotationItem;
mRotationItem = nullptr;
delete mRotationPreviewBox;
mRotationPreviewBox = nullptr;
QgsVectorLayer* vlayer = mCurrentLabel.layer;
if ( !vlayer )
{
return;
}
int rotationCol;
if ( !labelIsRotatable( vlayer, mCurrentLabel.settings, rotationCol ) )
{
return;
}
double rotation = mCtrlPressed ? roundTo15Degrees( mCurrentRotation ) : mCurrentRotation;
if ( rotation == mStartRotation ) //mouse button pressed / released, but no rotation
{
return;
}
vlayer->beginEditCommand( tr( "Rotated label" ) + QString( " '%1'" ).arg( currentLabelText( 24 ) ) );
vlayer->changeAttributeValue( mCurrentLabel.pos.featureId, rotationCol, rotation );
vlayer->endEditCommand();
vlayer->triggerRepaint();
}
void QgsAttributeTableDelegate::setModelData( QWidget *editor, QAbstractItemModel *model, const QModelIndex &index ) const
{
QgsVectorLayer *vl = layer( model );
if ( vl == NULL )
return;
int fieldIdx = model->data( index, QgsAttributeTableModel::FieldIndexRole ).toInt();
QgsFeatureId fid = model->data( index, QgsAttributeTableModel::FeatureIdRole ).toLongLong();
QVariant oldValue = model->data( index, Qt::EditRole );
QVariant newValue;
QgsEditorWidgetWrapper* eww = QgsEditorWidgetWrapper::fromWidget( editor );
if ( !eww )
return;
newValue = eww->value();
if (( oldValue != newValue && newValue.isValid() ) || oldValue.isNull() != newValue.isNull() )
{
vl->beginEditCommand( tr( "Attribute changed" ) );
vl->changeAttributeValue( fid, fieldIdx, newValue, oldValue );
vl->endEditCommand();
}
}
QDomDocument createTransactionDocument( QgsServerInterface* serverIface, const QString& version,
const QgsServerRequest& request )
{
Q_UNUSED( version );
QDomDocument doc;
QgsWfsProjectParser* configParser = getConfigParser( serverIface );
#ifdef HAVE_SERVER_PYTHON_PLUGINS
QgsAccessControl* accessControl = serverIface->accessControls();
#endif
const QString requestBody = request.getParameter( QStringLiteral( "REQUEST_BODY" ) );
QString errorMsg;
if ( !doc.setContent( requestBody, true, &errorMsg ) )
{
throw QgsRequestNotWellFormedException( errorMsg );
}
QDomElement docElem = doc.documentElement();
QDomNodeList docChildNodes = docElem.childNodes();
// Re-organize the transaction document
QDomDocument mDoc;
QDomElement mDocElem = mDoc.createElement( QStringLiteral( "myTransactionDocument" ) );
mDocElem.setAttribute( QStringLiteral( "xmlns" ), QGS_NAMESPACE );
mDocElem.setAttribute( QStringLiteral( "xmlns:wfs" ), WFS_NAMESPACE );
mDocElem.setAttribute( QStringLiteral( "xmlns:gml" ), GML_NAMESPACE );
mDocElem.setAttribute( QStringLiteral( "xmlns:ogc" ), OGC_NAMESPACE );
mDocElem.setAttribute( QStringLiteral( "xmlns:qgs" ), QGS_NAMESPACE );
mDocElem.setAttribute( QStringLiteral( "xmlns:xsi" ), QStringLiteral( "http://www.w3.org/2001/XMLSchema-instance" ) );
mDoc.appendChild( mDocElem );
QDomElement actionElem;
QString actionName;
QDomElement typeNameElem;
QString typeName;
for ( int i = docChildNodes.count(); 0 < i; --i )
{
actionElem = docChildNodes.at( i - 1 ).toElement();
actionName = actionElem.localName();
if ( actionName == QLatin1String( "Insert" ) )
{
QDomElement featureElem = actionElem.firstChild().toElement();
typeName = featureElem.localName();
}
else if ( actionName == QLatin1String( "Update" ) )
{
typeName = actionElem.attribute( QStringLiteral( "typeName" ) );
}
else if ( actionName == QLatin1String( "Delete" ) )
{
typeName = actionElem.attribute( QStringLiteral( "typeName" ) );
}
if ( typeName.contains( QLatin1String( ":" ) ) )
typeName = typeName.section( QStringLiteral( ":" ), 1, 1 );
QDomNodeList typeNameList = mDocElem.elementsByTagName( typeName );
if ( typeNameList.count() == 0 )
{
typeNameElem = mDoc.createElement( typeName );
mDocElem.appendChild( typeNameElem );
}
else
typeNameElem = typeNameList.at( 0 ).toElement();
typeNameElem.appendChild( actionElem );
}
// It's time to make the transaction
// Create the response document
QDomDocument resp;
//wfs:WFS_TransactionRespone element
QDomElement respElem = resp.createElement( QStringLiteral( "WFS_TransactionResponse" )/*wfs:WFS_TransactionResponse*/ );
respElem.setAttribute( QStringLiteral( "xmlns" ), WFS_NAMESPACE );
respElem.setAttribute( QStringLiteral( "xmlns:xsi" ), QStringLiteral( "http://www.w3.org/2001/XMLSchema-instance" ) );
respElem.setAttribute( QStringLiteral( "xsi:schemaLocation" ), WFS_NAMESPACE + " http://schemas.opengis.net/wfs/1.0.0/wfs.xsd" );
respElem.setAttribute( QStringLiteral( "xmlns:ogc" ), OGC_NAMESPACE );
respElem.setAttribute( QStringLiteral( "version" ), QStringLiteral( "1.0.0" ) );
resp.appendChild( respElem );
// Store the created feature id for WFS
QStringList insertResults;
// Get the WFS layers id
QStringList wfsLayersId = configParser->wfsLayers();;
QList<QgsMapLayer*> layerList;
QgsMapLayer* currentLayer = nullptr;
// Loop through the layer transaction elements
docChildNodes = mDocElem.childNodes();
for ( int i = 0; i < docChildNodes.count(); ++i )
{
// Get the vector layer
typeNameElem = docChildNodes.at( i ).toElement();
typeName = typeNameElem.tagName();
layerList = configParser->mapLayerFromTypeName( typeName );
// Could be empty!
if ( layerList.count() > 0 )
{
currentLayer = layerList.at( 0 );
}
else
{
throw QgsRequestNotWellFormedException( QStringLiteral( "Wrong TypeName: %1" ).arg( typeName ) );
}
QgsVectorLayer* layer = qobject_cast<QgsVectorLayer*>( currentLayer );
// it's a vectorlayer and defined by the administrator as a WFS layer
if ( layer && wfsLayersId.contains( layer->id() ) )
{
#ifdef HAVE_SERVER_PYTHON_PLUGINS
if ( actionName == QLatin1String( "Insert" ) )
{
if ( !accessControl->layerInsertPermission( layer ) )
{
throw QgsSecurityAccessException( QStringLiteral( "Feature insert permission denied" ) );
}
}
else if ( actionName == QLatin1String( "Update" ) )
{
if ( !accessControl->layerUpdatePermission( layer ) )
{
throw QgsSecurityAccessException( QStringLiteral( "Feature update permission denied" ) );
}
}
else if ( actionName == QLatin1String( "Delete" ) )
{
if ( !accessControl->layerDeletePermission( layer ) )
{
throw QgsSecurityAccessException( QStringLiteral( "Feature delete permission denied" ) );
}
}
#endif
// Get the provider and it's capabilities
QgsVectorDataProvider* provider = layer->dataProvider();
if ( !provider )
{
continue;
}
int cap = provider->capabilities();
// Start the update transaction
layer->startEditing();
if (( cap & QgsVectorDataProvider::ChangeAttributeValues ) && ( cap & QgsVectorDataProvider::ChangeGeometries ) )
{
// Loop through the update elements for this layer
QDomNodeList upNodeList = typeNameElem.elementsByTagNameNS( WFS_NAMESPACE, QStringLiteral( "Update" ) );
for ( int j = 0; j < upNodeList.count(); ++j )
{
if ( !configParser->wfstUpdateLayers().contains( layer->id() ) )
{
//no wfs permissions to do updates
QString errorMsg = "No permissions to do WFS updates on layer '" + layer->name() + "'";
QgsMessageLog::logMessage( errorMsg, QStringLiteral( "Server" ), QgsMessageLog::CRITICAL );
addTransactionResult( resp, respElem, QStringLiteral( "FAILED" ), QStringLiteral( "Update" ), errorMsg );
return resp;
}
actionElem = upNodeList.at( j ).toElement();
// Get the Feature Ids for this filter on the layer
QDomElement filterElem = actionElem.elementsByTagName( QStringLiteral( "Filter" ) ).at( 0 ).toElement();
QgsFeatureIds fids = getFeatureIdsFromFilter( filterElem, layer );
// Loop through the property elements
// Store properties and the geometry element
QDomNodeList propertyNodeList = actionElem.elementsByTagName( QStringLiteral( "Property" ) );
QMap<QString, QString> propertyMap;
QDomElement propertyElem;
QDomElement nameElem;
QDomElement valueElem;
QDomElement geometryElem;
for ( int l = 0; l < propertyNodeList.count(); ++l )
{
propertyElem = propertyNodeList.at( l ).toElement();
nameElem = propertyElem.elementsByTagName( QStringLiteral( "Name" ) ).at( 0 ).toElement();
valueElem = propertyElem.elementsByTagName( QStringLiteral( "Value" ) ).at( 0 ).toElement();
if ( nameElem.text() != QLatin1String( "geometry" ) )
{
propertyMap.insert( nameElem.text(), valueElem.text() );
}
else
{
geometryElem = valueElem;
}
}
// Update the features
QgsFields fields = provider->fields();
QMap<QString, int> fieldMap = provider->fieldNameMap();
QMap<QString, int>::const_iterator fieldMapIt;
QString fieldName;
bool conversionSuccess;
QgsFeatureIds::const_iterator fidIt = fids.constBegin();
for ( ; fidIt != fids.constEnd(); ++fidIt )
{
#ifdef HAVE_SERVER_PYTHON_PLUGINS
QgsFeatureIterator fit = layer->getFeatures( QgsFeatureRequest( *fidIt ) );
QgsFeature feature;
while ( fit.nextFeature( feature ) )
{
if ( !accessControl->allowToEdit( layer, feature ) )
{
throw QgsSecurityAccessException( QStringLiteral( "Feature modify permission denied" ) );
}
}
#endif
QMap< QString, QString >::const_iterator it = propertyMap.constBegin();
for ( ; it != propertyMap.constEnd(); ++it )
{
fieldName = it.key();
fieldMapIt = fieldMap.find( fieldName );
if ( fieldMapIt == fieldMap.constEnd() )
{
continue;
}
QgsField field = fields.at( fieldMapIt.value() );
if ( field.type() == 2 )
layer->changeAttributeValue( *fidIt, fieldMapIt.value(), it.value().toInt( &conversionSuccess ) );
else if ( field.type() == 6 )
layer->changeAttributeValue( *fidIt, fieldMapIt.value(), it.value().toDouble( &conversionSuccess ) );
else
layer->changeAttributeValue( *fidIt, fieldMapIt.value(), it.value() );
}
if ( !geometryElem.isNull() )
{
QgsGeometry g = QgsOgcUtils::geometryFromGML( geometryElem );
if ( !layer->changeGeometry( *fidIt, g ) )
{
throw QgsRequestNotWellFormedException( QStringLiteral( "Error in change geometry" ) );
}
}
#ifdef HAVE_SERVER_PYTHON_PLUGINS
fit = layer->getFeatures( QgsFeatureRequest( *fidIt ) );
while ( fit.nextFeature( feature ) )
{
if ( !accessControl->allowToEdit( layer, feature ) )
{
layer->rollBack();
throw QgsSecurityAccessException( QStringLiteral( "Feature modify permission denied" ) );
}
}
#endif
}
}
}
// Commit the changes of the update elements
if ( !layer->commitChanges() )
{
addTransactionResult( resp, respElem, QStringLiteral( "PARTIAL" ), QStringLiteral( "Update" ), layer->commitErrors().join( QStringLiteral( "\n " ) ) );
return resp;
}
// Start the delete transaction
layer->startEditing();
if (( cap & QgsVectorDataProvider::DeleteFeatures ) )
{
// Loop through the delete elements
QDomNodeList delNodeList = typeNameElem.elementsByTagNameNS( WFS_NAMESPACE, QStringLiteral( "Delete" ) );
for ( int j = 0; j < delNodeList.count(); ++j )
{
if ( !configParser->wfstDeleteLayers().contains( layer->id() ) )
{
//no wfs permissions to do updates
QString errorMsg = "No permissions to do WFS deletes on layer '" + layer->name() + "'";
QgsMessageLog::logMessage( errorMsg, QStringLiteral( "Server" ), QgsMessageLog::CRITICAL );
addTransactionResult( resp, respElem, QStringLiteral( "FAILED" ), QStringLiteral( "Delete" ), errorMsg );
return resp;
}
actionElem = delNodeList.at( j ).toElement();
QDomElement filterElem = actionElem.firstChild().toElement();
// Get Feature Ids for the Filter element
QgsFeatureIds fids = getFeatureIdsFromFilter( filterElem, layer );
#ifdef HAVE_SERVER_PYTHON_PLUGINS
QgsFeatureIds::const_iterator fidIt = fids.constBegin();
for ( ; fidIt != fids.constEnd(); ++fidIt )
{
QgsFeatureIterator fit = layer->getFeatures( QgsFeatureRequest( *fidIt ) );
QgsFeature feature;
while ( fit.nextFeature( feature ) )
{
if ( !accessControl->allowToEdit( layer, feature ) )
{
throw QgsSecurityAccessException( QStringLiteral( "Feature modify permission denied" ) );
}
}
}
#endif
layer->selectByIds( fids );
layer->deleteSelectedFeatures();
}
}
// Commit the changes of the delete elements
if ( !layer->commitChanges() )
{
addTransactionResult( resp, respElem, QStringLiteral( "PARTIAL" ), QStringLiteral( "Delete" ), layer->commitErrors().join( QStringLiteral( "\n " ) ) );
return resp;
}
// Store the inserted features
QgsFeatureList inFeatList;
if ( cap & QgsVectorDataProvider::AddFeatures )
{
// Get Layer Field Information
QgsFields fields = provider->fields();
QMap<QString, int> fieldMap = provider->fieldNameMap();
QMap<QString, int>::const_iterator fieldMapIt;
// Loop through the insert elements
QDomNodeList inNodeList = typeNameElem.elementsByTagNameNS( WFS_NAMESPACE, QStringLiteral( "Insert" ) );
for ( int j = 0; j < inNodeList.count(); ++j )
{
if ( !configParser->wfstInsertLayers().contains( layer->id() ) )
{
//no wfs permissions to do updates
QString errorMsg = "No permissions to do WFS inserts on layer '" + layer->name() + "'";
QgsMessageLog::logMessage( errorMsg, QStringLiteral( "Server" ), QgsMessageLog::CRITICAL );
addTransactionResult( resp, respElem, QStringLiteral( "FAILED" ), QStringLiteral( "Insert" ), errorMsg );
return resp;
}
actionElem = inNodeList.at( j ).toElement();
// Loop through the feature element
QDomNodeList featNodes = actionElem.childNodes();
for ( int l = 0; l < featNodes.count(); l++ )
{
// Add the feature to the layer
// and store it to put it's Feature Id in the response
inFeatList << QgsFeature( fields );
// Create feature for this layer
QDomElement featureElem = featNodes.at( l ).toElement();
QDomNode currentAttributeChild = featureElem.firstChild();
while ( !currentAttributeChild.isNull() )
{
QDomElement currentAttributeElement = currentAttributeChild.toElement();
QString attrName = currentAttributeElement.localName();
if ( attrName != QLatin1String( "boundedBy" ) )
{
if ( attrName != QLatin1String( "geometry" ) ) //a normal attribute
{
fieldMapIt = fieldMap.find( attrName );
if ( fieldMapIt == fieldMap.constEnd() )
{
continue;
}
QgsField field = fields.at( fieldMapIt.value() );
QString attrValue = currentAttributeElement.text();
int attrType = field.type();
QgsMessageLog::logMessage( QStringLiteral( "attr: name=%1 idx=%2 value=%3" ).arg( attrName ).arg( fieldMapIt.value() ).arg( attrValue ) );
if ( attrType == QVariant::Int )
inFeatList.last().setAttribute( fieldMapIt.value(), attrValue.toInt() );
else if ( attrType == QVariant::Double )
inFeatList.last().setAttribute( fieldMapIt.value(), attrValue.toDouble() );
else
inFeatList.last().setAttribute( fieldMapIt.value(), attrValue );
}
else //a geometry attribute
{
QgsGeometry g = QgsOgcUtils::geometryFromGML( currentAttributeElement );
inFeatList.last().setGeometry( g );
}
}
currentAttributeChild = currentAttributeChild.nextSibling();
}
}
}
}
#ifdef HAVE_SERVER_PYTHON_PLUGINS
QgsFeatureList::iterator featureIt = inFeatList.begin();
while ( featureIt != inFeatList.end() )
{
if ( !accessControl->allowToEdit( layer, *featureIt ) )
{
throw QgsSecurityAccessException( QStringLiteral( "Feature modify permission denied" ) );
}
featureIt++;
}
#endif
// add the features
if ( !provider->addFeatures( inFeatList ) )
{
addTransactionResult( resp, respElem, QStringLiteral( "Partial" ), QStringLiteral( "Insert" ), layer->commitErrors().join( QStringLiteral( "\n " ) ) );
if ( provider->hasErrors() )
{
provider->clearErrors();
}
return resp;
}
// Get the Feature Ids of the inserted feature
for ( int j = 0; j < inFeatList.size(); j++ )
{
insertResults << typeName + "." + QString::number( inFeatList[j].id() );
}
}
}
// Put the Feature Ids of the inserted feature
if ( !insertResults.isEmpty() )
{
Q_FOREACH ( const QString &fidStr, insertResults )
{
QDomElement irElem = doc.createElement( QStringLiteral( "InsertResult" ) );
QDomElement fiElem = doc.createElement( QStringLiteral( "ogc:FeatureId" ) );
fiElem.setAttribute( QStringLiteral( "fid" ), fidStr );
irElem.appendChild( fiElem );
respElem.appendChild( irElem );
}
void QgsMapToolMoveLabel::canvasReleaseEvent( QgsMapMouseEvent* e )
{
if ( !mLabelRubberBand )
{
return;
}
deleteRubberBands();
QgsMapLayer* layer = QgsMapLayerRegistry::instance()->mapLayer( mCurrentLabelPos.layerID );
if ( !layer )
{
return;
}
QgsVectorLayer* vlayer = dynamic_cast<QgsVectorLayer*>( layer );
if ( !vlayer )
{
return;
}
if ( !vlayer->isEditable() )
{
return;
}
QgsPoint releaseCoords = toMapCoordinates( e->pos() );
double xdiff = releaseCoords.x() - mStartPointMapCoords.x();
double ydiff = releaseCoords.y() - mStartPointMapCoords.y();
int xCol, yCol;
double xPosOrig, yPosOrig;
bool xSuccess, ySuccess;
if ( !dataDefinedPosition( vlayer, mCurrentLabelPos.featureId, xPosOrig, xSuccess, yPosOrig, ySuccess, xCol, yCol ) )
{
return;
}
double xPosNew, yPosNew;
if ( !xSuccess || !ySuccess )
{
xPosNew = releaseCoords.x() - mClickOffsetX;
yPosNew = releaseCoords.y() - mClickOffsetY;
}
else
{
//transform to map crs first, because xdiff,ydiff are in map coordinates
const QgsMapSettings& ms = mCanvas->mapSettings();
if ( ms.hasCrsTransformEnabled() )
{
QgsPoint transformedPoint = ms.layerToMapCoordinates( vlayer, QgsPoint( xPosOrig, yPosOrig ) );
xPosOrig = transformedPoint.x();
yPosOrig = transformedPoint.y();
}
xPosNew = xPosOrig + xdiff;
yPosNew = yPosOrig + ydiff;
}
//transform back to layer crs
if ( mCanvas )
{
const QgsMapSettings& s = mCanvas->mapSettings();
if ( s.hasCrsTransformEnabled() )
{
QgsPoint transformedPoint = s.mapToLayerCoordinates( vlayer, QgsPoint( xPosNew, yPosNew ) );
xPosNew = transformedPoint.x();
yPosNew = transformedPoint.y();
}
}
vlayer->beginEditCommand( tr( "Moved label" ) + QString( " '%1'" ).arg( currentLabelText( 24 ) ) );
vlayer->changeAttributeValue( mCurrentLabelPos.featureId, xCol, xPosNew );
vlayer->changeAttributeValue( mCurrentLabelPos.featureId, yCol, yPosNew );
// set rotation to that of label, if data-defined and no rotation set yet
// honor whether to preserve preexisting data on pin
// must come after setting x and y positions
int rCol;
if ( !mCurrentLabelPos.isDiagram
&& !mCurrentLabelPos.isPinned
&& !preserveRotation()
&& layerIsRotatable( vlayer, rCol ) )
{
double defRot;
bool rSuccess;
if ( dataDefinedRotation( vlayer, mCurrentLabelPos.featureId, defRot, rSuccess ) )
{
double labelRot = mCurrentLabelPos.rotation * 180 / M_PI;
vlayer->changeAttributeValue( mCurrentLabelPos.featureId, rCol, labelRot );
}
}
vlayer->endEditCommand();
if ( mCanvas )
mCanvas->refresh();
}
bool QgsMapToolPinLabels::pinUnpinCurrentLabel( bool pin )
{
QgsVectorLayer *vlayer = mCurrentLabel.layer;
const QgsLabelPosition &labelpos = mCurrentLabel.pos;
// skip diagrams
if ( labelpos.isDiagram )
{
QgsDebugMsg( QStringLiteral( "Label is diagram, skipping" ) );
return false;
}
// verify attribute table has x, y fields mapped
int xCol, yCol;
double xPosOrig, yPosOrig;
bool xSuccess, ySuccess;
if ( !currentLabelDataDefinedPosition( xPosOrig, xSuccess, yPosOrig, ySuccess, xCol, yCol ) )
{
QgsDebugMsg( QStringLiteral( "Label X or Y column not mapped, skipping" ) );
return false;
}
// rotation field is optional, but will be used if available, unless data exists
int rCol;
bool rSuccess = false;
double defRot;
bool hasRCol = currentLabelDataDefinedRotation( defRot, rSuccess, rCol, true );
// get whether to preserve predefined rotation data during label pin/unpin operations
bool preserveRot = currentLabelPreserveRotation();
// edit attribute table
int fid = labelpos.featureId;
bool writeFailed = false;
QString labelText = currentLabelText( 24 );
if ( pin )
{
// QgsPointXY labelpoint = labelpos.cornerPoints.at( 0 );
QgsPointXY referencePoint;
if ( !currentLabelRotationPoint( referencePoint, !preserveRot, false ) )
{
referencePoint.setX( labelpos.labelRect.xMinimum() );
referencePoint.setY( labelpos.labelRect.yMinimum() );
}
double labelX = referencePoint.x();
double labelY = referencePoint.y();
double labelR = labelpos.rotation * 180 / M_PI;
// transform back to layer crs
QgsPointXY transformedPoint = mCanvas->mapSettings().mapToLayerCoordinates( vlayer, referencePoint );
labelX = transformedPoint.x();
labelY = transformedPoint.y();
vlayer->beginEditCommand( tr( "Pinned label" ) + QStringLiteral( " '%1'" ).arg( labelText ) );
writeFailed = !vlayer->changeAttributeValue( fid, xCol, labelX );
if ( !vlayer->changeAttributeValue( fid, yCol, labelY ) )
writeFailed = true;
if ( hasRCol && !preserveRot )
{
if ( !vlayer->changeAttributeValue( fid, rCol, labelR ) )
writeFailed = true;
}
vlayer->endEditCommand();
}
else
{
vlayer->beginEditCommand( tr( "Unpinned label" ) + QStringLiteral( " '%1'" ).arg( labelText ) );
writeFailed = !vlayer->changeAttributeValue( fid, xCol, QVariant( QString() ) );
if ( !vlayer->changeAttributeValue( fid, yCol, QVariant( QString() ) ) )
writeFailed = true;
if ( hasRCol && !preserveRot )
{
if ( !vlayer->changeAttributeValue( fid, rCol, QVariant( QString() ) ) )
writeFailed = true;
}
vlayer->endEditCommand();
}
if ( writeFailed )
{
QgsDebugMsg( QStringLiteral( "Write to attribute table failed" ) );
#if 0
QgsDebugMsg( QStringLiteral( "Undoing and removing failed command from layer's undo stack" ) );
int lastCmdIndx = vlayer->undoStack()->count();
const QgsUndoCommand *lastCmd = qobject_cast<const QgsUndoCommand *>( vlayer->undoStack()->command( lastCmdIndx ) );
if ( lastCmd )
{
vlayer->undoEditCommand( lastCmd );
delete vlayer->undoStack()->command( lastCmdIndx );
}
#endif
return false;
}
return true;
}
