HeatmapGui::HeatmapGui( QWidget* parent, Qt::WindowFlags fl, QMap<QString, QVariant>* temporarySettings )
: QDialog( parent, fl ),
mRows( 500 )
{
setupUi( this );
QgsDebugMsg( QString( "Creating Heatmap Dialog" ) );
blockAllSignals( true );
mHeatmapSessionSettings = temporarySettings;
// Adding point layers to the inputLayerCombo
QString defaultLayer = mHeatmapSessionSettings->value( QString( "lastInputLayer" ) ).toString();
int defaultLayerIndex = 0;
bool usingLastInputLayer = false;
int currentIndex = -1;
foreach ( QgsMapLayer *l, QgsMapLayerRegistry::instance()->mapLayers() )
{
QgsVectorLayer *vl = qobject_cast<QgsVectorLayer *>( l );
if ( !vl || vl->geometryType() != QGis::Point )
continue;
currentIndex++;
inputLayerCombo->addItem( vl->name(), vl->id() );
if ( vl->id() == defaultLayer )
{
// if this layer is the same layer as a heatmap was last generated using,
// then default to this layer
usingLastInputLayer = true;
defaultLayerIndex = currentIndex;
}
}
void QgsSpatialQueryDialog::populateCbTargetLayer()
{
cbTargetLayer->blockSignals( true );
QMap <QString, QgsMapLayer*> layers = QgsMapLayerRegistry::instance()->mapLayers();
QMapIterator <QString, QgsMapLayer*> item( layers );
QgsMapLayer * mapLayer = NULL;
QgsVectorLayer * lyr = NULL;
QString layerId;
while ( item.hasNext() )
{
item.next();
mapLayer = item.value();
if ( mapLayer->type() != QgsMapLayer::VectorLayer )
{
continue;
}
lyr = qobject_cast<QgsVectorLayer *>( mapLayer );
if ( !lyr )
{
continue;
}
addCbLayer( true, lyr );
mMapIdVectorLayers.insert( lyr->id(), lyr );
}
cbTargetLayer->setCurrentIndex( 0 );
cbTargetLayer->blockSignals( false );
} // void QgsSpatialQueryDialog::populateCbTargetLayer()
QgsAttributeTypeDialog::QgsAttributeTypeDialog( QgsVectorLayer *vl )
: QDialog()
, mLayer( vl )
{
setupUi( this );
tableWidget->insertRow( 0 );
connect( selectionListWidget, SIGNAL( currentRowChanged( int ) ), this, SLOT( setStackPage( int ) ) );
connect( removeSelectedButton, SIGNAL( clicked() ), this, SLOT( removeSelectedButtonPushed() ) );
connect( loadFromLayerButton, SIGNAL( clicked() ), this, SLOT( loadFromLayerButtonPushed() ) );
connect( loadFromCSVButton, SIGNAL( clicked() ), this, SLOT( loadFromCSVButtonPushed() ) );
connect( tableWidget, SIGNAL( cellChanged( int, int ) ), this, SLOT( vCellChanged( int, int ) ) );
connect( valueRelationEditExpression, SIGNAL( clicked() ), this, SLOT( editValueRelationExpression() ) );
QMapIterator<QString, QgsEditorWidgetFactory*> i( QgsEditorWidgetRegistry::instance()->factories() );
while ( i.hasNext() )
{
i.next();
QListWidgetItem* item = new QListWidgetItem( selectionListWidget );
item->setText( i.value()->name() );
item->setData( Qt::UserRole, i.key() );
selectionListWidget->addItem( item );
}
valueRelationLayer->clear();
foreach ( QgsMapLayer *l, QgsMapLayerRegistry::instance()->mapLayers() )
{
QgsVectorLayer *vl = qobject_cast< QgsVectorLayer * >( l );
if ( vl )
valueRelationLayer->addItem( vl->name(), vl->id() );
}
void QgsMapToolOffsetCurve::canvasReleaseEvent( QMouseEvent * e )
{
Q_UNUSED( e );
QgsVectorLayer* vlayer = currentVectorLayer();
if ( !vlayer )
{
deleteRubberBandAndGeometry();
return;
}
if ( !mGeometryModified )
{
deleteRubberBandAndGeometry();
vlayer->destroyEditCommand();
return;
}
if ( mMultiPartGeometry )
{
mModifiedGeometry.convertToMultiType();
}
vlayer->beginEditCommand( tr( "Offset curve" ) );
bool editOk;
if ( mSourceLayerId == vlayer->id() && !mForceCopy )
{
editOk = vlayer->changeGeometry( mModifiedFeature, &mModifiedGeometry );
}
else
{
QgsFeature f;
f.setGeometry( mModifiedGeometry );
//add empty values for all fields (allows inserting attribute values via the feature form in the same session)
QgsAttributes attrs( vlayer->pendingFields().count() );
const QgsFields& fields = vlayer->pendingFields();
for ( int idx = 0; idx < fields.count(); ++idx )
{
attrs[idx] = QVariant();
}
f.setAttributes( attrs );
editOk = vlayer->addFeature( f );
}
if ( editOk )
{
vlayer->endEditCommand();
}
else
{
vlayer->destroyEditCommand();
}
deleteRubberBandAndGeometry();
deleteDistanceItem();
delete mSnapVertexMarker; mSnapVertexMarker = 0;
mForceCopy = false;
mCanvas->refresh();
}
void QgsMapCanvasTracer::configure()
{
setCrsTransformEnabled( mCanvas->mapSettings().hasCrsTransformEnabled() );
setDestinationCrs( mCanvas->mapSettings().destinationCrs() );
setExtent( mCanvas->extent() );
QList<QgsVectorLayer*> layers;
QStringList visibleLayerIds = mCanvas->mapSettings().layers();
switch ( mCanvas->snappingUtils()->snapToMapMode() )
{
default:
case QgsSnappingUtils::SnapCurrentLayer:
{
QgsVectorLayer* vl = qobject_cast<QgsVectorLayer*>( mCanvas->currentLayer() );
if ( vl && visibleLayerIds.contains( vl->id() ) )
layers << vl;
}
break;
case QgsSnappingUtils::SnapAllLayers:
Q_FOREACH ( const QString& layerId, visibleLayerIds )
{
QgsVectorLayer* vl = qobject_cast<QgsVectorLayer*>( QgsMapLayerRegistry::instance()->mapLayer( layerId ) );
if ( vl )
layers << vl;
}
break;
case QgsSnappingUtils::SnapAdvanced:
Q_FOREACH ( const QgsSnappingUtils::LayerConfig& cfg, mCanvas->snappingUtils()->layers() )
{
if ( visibleLayerIds.contains( cfg.layer->id() ) )
layers << cfg.layer;
}
break;
}
void QgsZonalStatisticsDialog::insertAvailableLayers()
{
//insert available raster layers
//enter available layers into the combo box
QMap<QString, QgsMapLayer*> mapLayers = QgsMapLayerRegistry::instance()->mapLayers();
QMap<QString, QgsMapLayer*>::iterator layer_it = mapLayers.begin();
for ( ; layer_it != mapLayers.end(); ++layer_it )
{
QgsRasterLayer* rl = dynamic_cast<QgsRasterLayer*>( layer_it.value() );
if ( rl )
{
QgsRasterDataProvider* rp = rl->dataProvider();
if ( rp && rp->name() == "gdal" )
{
mRasterLayerComboBox->addItem( rl->name(), QVariant( rl->id() ) );
}
}
else
{
QgsVectorLayer* vl = dynamic_cast<QgsVectorLayer*>( layer_it.value() );
if ( vl && vl->geometryType() == QGis::Polygon )
{
QgsVectorDataProvider* provider = vl->dataProvider();
if ( provider->capabilities() & QgsVectorDataProvider::AddAttributes )
{
mPolygonLayerComboBox->addItem( vl->name(), QVariant( vl->id() ) );
}
}
}
}
}
void QgsMapToolShowHideLabels::showHideLabels( QMouseEvent *e )
{
QgsMapLayer *layer = mCanvas->currentLayer();
QgsVectorLayer *vlayer = dynamic_cast<QgsVectorLayer *>( layer );
if ( !vlayer )
return;
bool doHide = e->modifiers() & Qt::ShiftModifier;
QString editTxt = doHide ? tr( "Hid labels" ) : tr( "Showed labels" );
vlayer->beginEditCommand( editTxt );
bool labelChanged = false;
if ( doHide )
{
QList<QgsLabelPosition> positions;
if ( selectedLabelFeatures( vlayer, positions ) )
{
for ( const QgsLabelPosition &pos : qgis::as_const( positions ) )
{
if ( showHide( pos, false ) )
labelChanged = true;
}
}
}
else
{
QgsFeatureIds fids;
if ( selectedFeatures( vlayer, fids ) )
{
for ( const QgsFeatureId &fid : qgis::as_const( fids ) )
{
QgsLabelPosition pos;
pos.featureId = fid;
pos.layerID = vlayer->id();
// we want to show labels...
pos.isDiagram = false;
if ( showHide( pos, true ) )
labelChanged = true;
// ... and diagrams
pos.isDiagram = true;
if ( showHide( pos, true ) )
labelChanged = true;
}
}
}
if ( labelChanged )
{
vlayer->endEditCommand();
vlayer->triggerRepaint();
}
else
{
vlayer->destroyEditCommand();
}
}
void QgsAttributeTypeLoadDialog::fillLayerList()
{
layerComboBox->clear();
foreach ( QgsMapLayer *l, QgsMapLayerRegistry::instance()->mapLayers() )
{
QgsVectorLayer *vl = qobject_cast< QgsVectorLayer * >( l );
if ( vl )
layerComboBox->addItem( vl->name(), vl->id() );
}
QStringList QgsEmbeddedLayerSelectDialog::layers() const
{
QStringList ids;
QModelIndexList selected = mLayers->selectionModel()->selectedRows();
for ( int i = 0; i < selected.size(); i++ )
{
QgsVectorLayer* l = static_cast<QgsVectorLayer*>( mLayers->item( selected[i].row() )->data( Qt::UserRole ).value<void*>() );
ids << l->id();
}
return ids;
}
QList< QPair<QgsVectorLayer *, int> > QgsVectorLayerAndAttributeModel::layers() const
{
QList< QPair<QgsVectorLayer *, int> > layers;
QHash< QString, int > layerIdx;
Q_FOREACH ( const QModelIndex &idx, mCheckedLeafs )
{
QgsLayerTreeNode *node = index2node( idx );
if ( QgsLayerTree::isGroup( node ) )
{
Q_FOREACH ( QgsLayerTreeLayer *treeLayer, QgsLayerTree::toGroup( node )->findLayers() )
{
QgsVectorLayer *vl = qobject_cast<QgsVectorLayer *>( treeLayer->layer() );
Q_ASSERT( vl );
if ( !layerIdx.contains( vl->id() ) )
{
layerIdx.insert( vl->id(), layers.size() );
layers << qMakePair<QgsVectorLayer *, int>( vl, mAttributeIdx.value( vl, -1 ) );
}
}
}
QgsVirtualLayerDefinition QgsVirtualLayerDefinitionUtils::fromJoinedLayer( QgsVectorLayer *layer )
{
QgsVirtualLayerDefinition def;
QStringList leftJoins;
QStringList columns;
// look for the uid
QgsFields fields = layer->dataProvider()->fields();
{
QgsAttributeList pk = layer->dataProvider()->pkAttributeIndexes();
if ( pk.size() == 1 )
{
def.setUid( fields.field( pk[0] ).name() );
}
else
{
// find an uid name
QString uid = QStringLiteral( "uid" );
while ( fields.lookupField( uid ) != -1 )
uid += QLatin1String( "_" ); // add "_" each time this name already exists
// add a column
columns << "t.rowid AS " + uid;
def.setUid( uid );
}
}
Q_FOREACH ( const QgsField &f, layer->dataProvider()->fields() )
{
columns << "t." + f.name();
}
int joinIdx = 0;
Q_FOREACH ( const QgsVectorLayerJoinInfo &join, layer->vectorJoins() )
{
QString joinName = QStringLiteral( "j%1" ).arg( ++joinIdx );
QgsVectorLayer *joinedLayer = join.joinLayer();
if ( !joinedLayer )
continue;
QString prefix = join.prefix().isEmpty() ? joinedLayer->name() + "_" : join.prefix();
leftJoins << QStringLiteral( "LEFT JOIN %1 AS %2 ON t.\"%5\"=%2.\"%3\"" ).arg( joinedLayer->id(), joinName, join.joinFieldName(), join.targetFieldName() );
if ( join.joinFieldNamesSubset() )
{
Q_FOREACH ( const QString &f, *join.joinFieldNamesSubset() )
{
columns << joinName + "." + f + " AS " + prefix + f;
}
}
else
{
HeatmapGui::HeatmapGui( QWidget* parent, Qt::WFlags fl )
: QDialog( parent, fl )
{
setupUi( this );
// Adding point layers to the mInputVectorCombo
foreach( QgsMapLayer *l, QgsMapLayerRegistry::instance()->mapLayers() )
{
QgsVectorLayer *vl = qobject_cast<QgsVectorLayer *>( l );
if ( !vl || vl->geometryType() != QGis::Point )
continue;
mInputVectorCombo->addItem( vl->name(), vl->id() );
}
void QgsVectorLayerJoinBuffer::joinedLayerUpdatedFields()
{
QgsVectorLayer* joinedLayer = qobject_cast<QgsVectorLayer*>( sender() );
Q_ASSERT( joinedLayer );
// recache the joined layer
for ( QgsVectorJoinList::iterator it = mVectorJoins.begin(); it != mVectorJoins.end(); ++it )
{
if ( joinedLayer->id() == it->joinLayerId )
{
it->cachedAttributes.clear();
cacheJoinLayer( *it );
}
}
emit joinedFieldsChanged();
}
QgsAttributeTypeDialog::QgsAttributeTypeDialog( QgsVectorLayer *vl )
: QDialog()
, mLayer( vl )
{
setupUi( this );
tableWidget->insertRow( 0 );
connect( selectionComboBox, SIGNAL( currentIndexChanged( int ) ), this, SLOT( setStackPage( int ) ) );
connect( removeSelectedButton, SIGNAL( clicked() ), this, SLOT( removeSelectedButtonPushed() ) );
connect( loadFromLayerButton, SIGNAL( clicked() ), this, SLOT( loadFromLayerButtonPushed() ) );
connect( loadFromCSVButton, SIGNAL( clicked() ), this, SLOT( loadFromCSVButtonPushed() ) );
connect( tableWidget, SIGNAL( cellChanged( int, int ) ), this, SLOT( vCellChanged( int, int ) ) );
valueRelationLayer->clear();
foreach( QgsMapLayer *l, QgsMapLayerRegistry::instance()->mapLayers() )
{
QgsVectorLayer *vl = qobject_cast< QgsVectorLayer * >( l );
if ( vl )
valueRelationLayer->addItem( vl->name(), vl->id() );
}
//! Slots for signs of QGIS
void QgsSpatialQueryDialog::signal_qgis_layerWasAdded( QgsMapLayer* mapLayer )
{
if ( mapLayer->type() != QgsMapLayer::VectorLayer )
{
return;
}
QgsVectorLayer * lyr = qobject_cast<QgsVectorLayer *>( mapLayer );
if ( !lyr )
{
return;
}
addCbLayer( true, lyr );
if ( cbTargetLayer->count() > 1 && bbMain->button( QDialogButtonBox::Apply )->isHidden() )
{
bbMain->button( QDialogButtonBox::Apply )->show();
cbOperation->setEnabled( true );
cbResultFor->setEnabled( true );
}
addCbLayer( false, lyr );
mMapIdVectorLayers.insert( lyr->id(), lyr );
} // QgsSpatialQueryDialog::signal_qgis_layerWasAdded(QgsMapLayer* mapLayer)
RgExportDlg::RgExportDlg( QWidget* parent, Qt::WindowFlags fl )
: QDialog( parent, fl )
{
// create base widgets;
setWindowTitle( tr( "Export feature" ) );
QVBoxLayout *v = new QVBoxLayout( this );
QHBoxLayout *h = new QHBoxLayout();
QLabel *l = new QLabel( tr( "Select destination layer" ), this );
h->addWidget( l );
mcbLayers = new QComboBox( this );
h->addWidget( mcbLayers );
v->addLayout( h );
QDialogButtonBox *bb = new QDialogButtonBox( QDialogButtonBox::Ok | QDialogButtonBox::Cancel, Qt::Horizontal, this );
connect( bb, SIGNAL( accepted() ), this, SLOT( on_buttonBox_accepted() ) );
connect( bb, SIGNAL( rejected() ), this, SLOT( on_buttonBox_rejected() ) );
v->addWidget( bb );
//fill list of layers
mcbLayers->insertItem( 0, tr( "New temporary layer" ), QVariant( "-1" ) );
QMap<QString, QgsMapLayer*> mapLayers = QgsMapLayerRegistry::instance()->mapLayers();
QMap<QString, QgsMapLayer*>::iterator layer_it = mapLayers.begin();
for ( ; layer_it != mapLayers.end(); ++layer_it )
{
QgsVectorLayer* vl = dynamic_cast<QgsVectorLayer*>( layer_it.value() );
if ( !vl )
continue;
if ( vl->geometryType() != QGis::Line )
continue;
mcbLayers->insertItem( 0, vl->name(), QVariant( vl->id() ) );
}
} // RgSettingsDlg::RgSettingsDlg()
void QgsMapToolOffsetCurve::applyOffset()
{
QgsVectorLayer* layer = currentVectorLayer();
if ( !layer )
{
deleteRubberBandAndGeometry();
notifyNotVectorLayer();
return;
}
// no modification
if ( !mGeometryModified )
{
deleteRubberBandAndGeometry();
layer->destroyEditCommand();
deleteDistanceWidget();
return;
}
if ( mMultiPartGeometry )
{
mModifiedGeometry.convertToMultiType();
}
layer->beginEditCommand( tr( "Offset curve" ) );
bool editOk;
if ( mSourceLayerId == layer->id() && !mForceCopy )
{
editOk = layer->changeGeometry( mModifiedFeature, &mModifiedGeometry );
}
else
{
QgsFeature f;
f.setGeometry( mModifiedGeometry );
//add empty values for all fields (allows inserting attribute values via the feature form in the same session)
QgsAttributes attrs( layer->fields().count() );
const QgsFields& fields = layer->fields();
for ( int idx = 0; idx < fields.count(); ++idx )
{
attrs[idx] = QVariant();
}
f.setAttributes( attrs );
editOk = layer->addFeature( f );
}
if ( editOk )
{
layer->endEditCommand();
}
else
{
layer->destroyEditCommand();
}
deleteRubberBandAndGeometry();
deleteDistanceWidget();
delete mSnapVertexMarker;
mSnapVertexMarker = nullptr;
mForceCopy = false;
mCanvas->refresh();
}
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 QgsOfflineEditing::copyVectorLayer( QgsVectorLayer* layer, sqlite3* db, const QString& offlineDbPath )
{
if ( layer == NULL )
{
return;
}
QString tableName = layer->name();
// create table
QString sql = QString( "CREATE TABLE '%1' (" ).arg( tableName );
QString delim = "";
const QgsFields& fields = layer->dataProvider()->fields();
for ( int idx = 0; idx < fields.count(); ++idx )
{
QString dataType = "";
QVariant::Type type = fields[idx].type();
if ( type == QVariant::Int )
{
dataType = "INTEGER";
}
else if ( type == QVariant::Double )
{
dataType = "REAL";
}
else if ( type == QVariant::String )
{
dataType = "TEXT";
}
else
{
showWarning( tr( "Unknown data type %1" ).arg( type ) );
}
sql += delim + QString( "'%1' %2" ).arg( fields[idx].name() ).arg( dataType );
delim = ",";
}
sql += ")";
// add geometry column
QString geomType = "";
switch ( layer->wkbType() )
{
case QGis::WKBPoint:
geomType = "POINT";
break;
case QGis::WKBMultiPoint:
geomType = "MULTIPOINT";
break;
case QGis::WKBLineString:
geomType = "LINESTRING";
break;
case QGis::WKBMultiLineString:
geomType = "MULTILINESTRING";
break;
case QGis::WKBPolygon:
geomType = "POLYGON";
break;
case QGis::WKBMultiPolygon:
geomType = "MULTIPOLYGON";
break;
default:
showWarning( tr( "QGIS wkbType %1 not supported" ).arg( layer->wkbType() ) );
break;
};
QString sqlAddGeom = QString( "SELECT AddGeometryColumn('%1', 'Geometry', %2, '%3', 2)" )
.arg( tableName )
.arg( layer->crs().authid().startsWith( "EPSG:", Qt::CaseInsensitive ) ? layer->crs().authid().mid( 5 ).toLong() : 0 )
.arg( geomType );
// create spatial index
QString sqlCreateIndex = QString( "SELECT CreateSpatialIndex('%1', 'Geometry')" ).arg( tableName );
int rc = sqlExec( db, sql );
if ( rc == SQLITE_OK )
{
rc = sqlExec( db, sqlAddGeom );
if ( rc == SQLITE_OK )
{
rc = sqlExec( db, sqlCreateIndex );
}
}
if ( rc == SQLITE_OK )
{
// add new layer
QgsVectorLayer* newLayer = new QgsVectorLayer( QString( "dbname='%1' table='%2'(Geometry) sql=" )
.arg( offlineDbPath ).arg( tableName ), tableName + " (offline)", "spatialite" );
if ( newLayer->isValid() )
{
// mark as offline layer
newLayer->setCustomProperty( CUSTOM_PROPERTY_IS_OFFLINE_EDITABLE, true );
// store original layer source
newLayer->setCustomProperty( CUSTOM_PROPERTY_REMOTE_SOURCE, layer->source() );
newLayer->setCustomProperty( CUSTOM_PROPERTY_REMOTE_PROVIDER, layer->providerType() );
// copy style
bool hasLabels = layer->hasLabelsEnabled();
if ( !hasLabels )
{
// NOTE: copy symbology before adding the layer so it is displayed correctly
copySymbology( layer, newLayer );
}
// register this layer with the central layers registry
QgsMapLayerRegistry::instance()->addMapLayers(
QList<QgsMapLayer *>() << newLayer );
if ( hasLabels )
{
// NOTE: copy symbology of layers with labels enabled after adding to project, as it will crash otherwise (WORKAROUND)
copySymbology( layer, newLayer );
}
// TODO: layer order
// copy features
newLayer->startEditing();
QgsFeature f;
// NOTE: force feature recount for PostGIS layer, else only visible features are counted, before iterating over all features (WORKAROUND)
layer->setSubsetString( "" );
QgsFeatureIterator fit = layer->getFeatures();
emit progressModeSet( QgsOfflineEditing::CopyFeatures, layer->featureCount() );
int featureCount = 1;
QList<QgsFeatureId> remoteFeatureIds;
while ( fit.nextFeature( f ) )
{
remoteFeatureIds << f.id();
// NOTE: Spatialite provider ignores position of geometry column
// fill gap in QgsAttributeMap if geometry column is not last (WORKAROUND)
int column = 0;
QgsAttributes attrs = f.attributes();
QgsAttributes newAttrs( attrs.count() );
for ( int it = 0; it < attrs.count(); ++it )
{
newAttrs[column++] = attrs[it];
}
f.setAttributes( newAttrs );
newLayer->addFeature( f, false );
emit progressUpdated( featureCount++ );
}
if ( newLayer->commitChanges() )
{
emit progressModeSet( QgsOfflineEditing::ProcessFeatures, layer->featureCount() );
featureCount = 1;
// update feature id lookup
int layerId = getOrCreateLayerId( db, newLayer->id() );
QList<QgsFeatureId> offlineFeatureIds;
QgsFeatureIterator fit = newLayer->getFeatures( QgsFeatureRequest().setFlags( QgsFeatureRequest::NoGeometry ).setSubsetOfAttributes( QgsAttributeList() ) );
while ( fit.nextFeature( f ) )
{
offlineFeatureIds << f.id();
}
// NOTE: insert fids in this loop, as the db is locked during newLayer->nextFeature()
sqlExec( db, "BEGIN" );
int remoteCount = remoteFeatureIds.size();
for ( int i = 0; i < remoteCount; i++ )
{
addFidLookup( db, layerId, offlineFeatureIds.at( i ), remoteFeatureIds.at( remoteCount - ( i + 1 ) ) );
emit progressUpdated( featureCount++ );
}
sqlExec( db, "COMMIT" );
}
else
{
showWarning( newLayer->commitErrors().join( "\n" ) );
}
// remove remote layer
QgsMapLayerRegistry::instance()->removeMapLayers(
QStringList() << layer->id() );
}
}
}
int QgsMapCanvasSnapper::snapToBackgroundLayers( const QgsPoint& point, QList<QgsSnappingResult>& results, const QList<QgsPoint>& excludePoints )
{
results.clear();
if ( !mSnapper )
return 5;
//topological editing on?
int topologicalEditing = QgsProject::instance()->readNumEntry( "Digitizing", "/TopologicalEditing", 0 );
//snapping on intersection on?
int intersectionSnapping = QgsProject::instance()->readNumEntry( "Digitizing", "/IntersectionSnapping", 0 );
if ( topologicalEditing == 0 )
{
if ( intersectionSnapping == 0 )
mSnapper->setSnapMode( QgsSnapper::SnapWithOneResult );
else
mSnapper->setSnapMode( QgsSnapper::SnapWithResultsWithinTolerances );
}
else if ( intersectionSnapping == 0 )
{
mSnapper->setSnapMode( QgsSnapper::SnapWithResultsForSamePosition );
}
else
{
mSnapper->setSnapMode( QgsSnapper::SnapWithResultsWithinTolerances );
}
QgsVectorLayer* currentVectorLayer = dynamic_cast<QgsVectorLayer*>( mMapCanvas->currentLayer() );
if ( !currentVectorLayer )
{
return 1;
}
//read snapping settings from project
QStringList layerIdList, enabledList, toleranceList, toleranceUnitList, snapToList;
bool ok, snappingDefinedInProject;
QSettings settings;
QString snappingMode = QgsProject::instance()->readEntry( "Digitizing", "/SnappingMode", "current_layer", &snappingDefinedInProject );
QString defaultSnapToleranceUnit = snappingDefinedInProject ? QgsProject::instance()->readEntry( "Digitizing", "/DefaultSnapToleranceUnit" ) : settings.value( "/qgis/digitizing/default_snapping_tolerance_unit", "0" ).toString();
QString defaultSnapType = snappingDefinedInProject ? QgsProject::instance()->readEntry( "Digitizing", "/DefaultSnapType" ) : settings.value( "/qgis/digitizing/default_snap_mode", "off" ).toString();
QString defaultSnapTolerance = snappingDefinedInProject ? QString::number( QgsProject::instance()->readDoubleEntry( "Digitizing", "/DefaultSnapTolerance" ) ) : settings.value( "/qgis/digitizing/default_snapping_tolerance", "0" ).toString();
if ( !snappingDefinedInProject && defaultSnapType == "off" )
{
return 0;
}
if ( snappingMode == "current_layer" || !snappingDefinedInProject )
{
layerIdList.append( currentVectorLayer->id() );
enabledList.append( "enabled" );
toleranceList.append( defaultSnapTolerance );
toleranceUnitList.append( defaultSnapToleranceUnit );
snapToList.append( defaultSnapType );
}
else if ( snappingMode == "all_layers" )
{
QList<QgsMapLayer*> allLayers = mMapCanvas->layers();
QList<QgsMapLayer*>::const_iterator layerIt = allLayers.constBegin();
for ( ; layerIt != allLayers.constEnd(); ++layerIt )
{
if ( !( *layerIt ) )
{
continue;
}
layerIdList.append(( *layerIt )->id() );
enabledList.append( "enabled" );
toleranceList.append( defaultSnapTolerance );
toleranceUnitList.append( defaultSnapToleranceUnit );
snapToList.append( defaultSnapType );
}
}
else //advanced
{
layerIdList = QgsProject::instance()->readListEntry( "Digitizing", "/LayerSnappingList", QStringList(), &ok );
enabledList = QgsProject::instance()->readListEntry( "Digitizing", "/LayerSnappingEnabledList", QStringList(), &ok );
toleranceList = QgsProject::instance()->readListEntry( "Digitizing", "/LayerSnappingToleranceList", QStringList(), &ok );
toleranceUnitList = QgsProject::instance()->readListEntry( "Digitizing", "/LayerSnappingToleranceUnitList", QStringList(), &ok );
snapToList = QgsProject::instance()->readListEntry( "Digitizing", "/LayerSnapToList", QStringList(), &ok );
}
if ( !( layerIdList.size() == enabledList.size() &&
layerIdList.size() == toleranceList.size() &&
layerIdList.size() == toleranceUnitList.size() &&
layerIdList.size() == snapToList.size() ) )
{
// lists must have the same size, otherwise something is wrong
return 1;
}
QList<QgsSnapper::SnapLayer> snapLayers;
QgsSnapper::SnapLayer snapLayer;
// set layers, tolerances, snap to segment/vertex to QgsSnapper
QStringList::const_iterator layerIt( layerIdList.constBegin() );
QStringList::const_iterator tolIt( toleranceList.constBegin() );
QStringList::const_iterator tolUnitIt( toleranceUnitList.constBegin() );
QStringList::const_iterator snapIt( snapToList.constBegin() );
QStringList::const_iterator enabledIt( enabledList.constBegin() );
for ( ; layerIt != layerIdList.constEnd(); ++layerIt, ++tolIt, ++tolUnitIt, ++snapIt, ++enabledIt )
{
if ( *enabledIt != "enabled" )
{
// skip layer if snapping is not enabled
continue;
}
//layer
QgsVectorLayer *vlayer = qobject_cast<QgsVectorLayer *>( QgsMapLayerRegistry::instance()->mapLayer( *layerIt ) );
if ( !vlayer || !vlayer->hasGeometryType() )
continue;
snapLayer.mLayer = vlayer;
//tolerance
snapLayer.mTolerance = tolIt->toDouble();
snapLayer.mUnitType = ( QgsTolerance::UnitType ) tolUnitIt->toInt();
// segment or vertex
if ( *snapIt == "to vertex" || *snapIt == "to_vertex" )
{
snapLayer.mSnapTo = QgsSnapper::SnapToVertex;
}
else if ( *snapIt == "to segment" || *snapIt == "to_segment" )
{
snapLayer.mSnapTo = QgsSnapper::SnapToSegment;
}
else if ( *snapIt == "to vertex and segment" || *snapIt == "to_vertex_and_segment" )
{
snapLayer.mSnapTo = QgsSnapper::SnapToVertexAndSegment;
}
else //off
{
continue;
}
snapLayers.append( snapLayer );
}
mSnapper->setSnapLayers( snapLayers );
if ( mSnapper->snapMapPoint( point, results, excludePoints ) != 0 )
return 4;
if ( intersectionSnapping != 1 )
return 0;
QList<QgsSnappingResult> segments;
QList<QgsSnappingResult> points;
for ( QList<QgsSnappingResult>::const_iterator it = results.constBegin();
it != results.constEnd();
++it )
{
if ( it->snappedVertexNr == -1 )
{
QgsDebugMsg( "segment" );
segments.push_back( *it );
}
else
{
QgsDebugMsg( "no segment" );
points.push_back( *it );
}
}
if ( segments.length() < 2 )
return 0;
QList<QgsSnappingResult> myResults;
for ( QList<QgsSnappingResult>::const_iterator oSegIt = segments.constBegin();
oSegIt != segments.constEnd();
++oSegIt )
{
QgsDebugMsg( QString::number( oSegIt->beforeVertexNr ) );
QVector<QgsPoint> vertexPoints;
vertexPoints.append( oSegIt->beforeVertex );
vertexPoints.append( oSegIt->afterVertex );
QgsGeometry* lineA = QgsGeometry::fromPolyline( vertexPoints );
for ( QList<QgsSnappingResult>::iterator iSegIt = segments.begin();
iSegIt != segments.end();
++iSegIt )
{
QVector<QgsPoint> vertexPoints;
vertexPoints.append( iSegIt->beforeVertex );
vertexPoints.append( iSegIt->afterVertex );
QgsGeometry* lineB = QgsGeometry::fromPolyline( vertexPoints );
QgsGeometry* intersectionPoint = lineA->intersection( lineB );
delete lineB;
if ( intersectionPoint && intersectionPoint->type() == QGis::Point )
{
//We have to check the intersection point is inside the tolerance distance for both layers
double toleranceA = 0;
double toleranceB = 0;
for ( int i = 0 ;i < snapLayers.size();++i )
{
if ( snapLayers[i].mLayer == oSegIt->layer )
{
toleranceA = QgsTolerance::toleranceInMapUnits( snapLayers[i].mTolerance, snapLayers[i].mLayer, mMapCanvas->mapSettings(), snapLayers[i].mUnitType );
}
if ( snapLayers[i].mLayer == iSegIt->layer )
{
toleranceB = QgsTolerance::toleranceInMapUnits( snapLayers[i].mTolerance, snapLayers[i].mLayer, mMapCanvas->mapSettings(), snapLayers[i].mUnitType );
}
}
QgsGeometry* cursorPoint = QgsGeometry::fromPoint( point );
double distance = intersectionPoint->distance( *cursorPoint );
if ( distance < toleranceA && distance < toleranceB )
{
iSegIt->snappedVertex = intersectionPoint->asPoint();
myResults.append( *iSegIt );
}
delete cursorPoint;
}
delete intersectionPoint;
}
delete lineA;
}
if ( myResults.length() > 0 )
{
results.clear();
results = myResults;
}
return 0;
}
QMenu* QgsAppLayerTreeViewMenuProvider::createContextMenu()
{
QMenu* menu = new QMenu;
QgsLayerTreeViewDefaultActions* actions = mView->defaultActions();
QModelIndex idx = mView->currentIndex();
if ( !idx.isValid() )
{
// global menu
menu->addAction( actions->actionAddGroup( menu ) );
menu->addAction( QgsApplication::getThemeIcon( "/mActionExpandTree.svg" ), tr( "&Expand All" ), mView, SLOT( expandAll() ) );
menu->addAction( QgsApplication::getThemeIcon( "/mActionCollapseTree.svg" ), tr( "&Collapse All" ), mView, SLOT( collapseAll() ) );
// TODO: update drawing order
}
else if ( QgsLayerTreeNode* node = mView->layerTreeModel()->index2node( idx ) )
{
// layer or group selected
if ( QgsLayerTree::isGroup( node ) )
{
menu->addAction( actions->actionZoomToGroup( mCanvas, menu ) );
menu->addAction( QgsApplication::getThemeIcon( "/mActionRemoveLayer.svg" ), tr( "&Remove" ), QgisApp::instance(), SLOT( removeLayer() ) );
menu->addAction( QgsApplication::getThemeIcon( "/mActionSetCRS.png" ),
tr( "&Set Group CRS" ), QgisApp::instance(), SLOT( legendGroupSetCRS() ) );
menu->addAction( actions->actionRenameGroupOrLayer( menu ) );
menu->addAction( tr( "&Set Group WMS data" ), QgisApp::instance(), SLOT( legendGroupSetWMSData() ) );
menu->addAction( actions->actionMutuallyExclusiveGroup( menu ) );
if ( mView->selectedNodes( true ).count() >= 2 )
menu->addAction( actions->actionGroupSelected( menu ) );
if ( QgisApp::instance()->clipboard()->hasFormat( QGSCLIPBOARD_STYLE_MIME ) )
{
menu->addAction( tr( "Paste Style" ), QgisApp::instance(), SLOT( applyStyleToGroup() ) );
}
menu->addAction( tr( "Save As Layer Definition File..." ), QgisApp::instance(), SLOT( saveAsLayerDefinition() ) );
menu->addAction( actions->actionAddGroup( menu ) );
}
else if ( QgsLayerTree::isLayer( node ) )
{
QgsMapLayer *layer = QgsLayerTree::toLayer( node )->layer();
QgsRasterLayer *rlayer = qobject_cast<QgsRasterLayer *>( layer );
QgsVectorLayer *vlayer = qobject_cast<QgsVectorLayer *>( layer );
menu->addAction( actions->actionZoomToLayer( mCanvas, menu ) );
menu->addAction( actions->actionShowInOverview( menu ) );
if ( rlayer )
{
menu->addAction( QgsApplication::getThemeIcon( "/mActionZoomActual.svg" ), tr( "&Zoom to Native Resolution (100%)" ), QgisApp::instance(), SLOT( legendLayerZoomNative() ) );
if ( rlayer->rasterType() != QgsRasterLayer::Palette )
menu->addAction( tr( "&Stretch Using Current Extent" ), QgisApp::instance(), SLOT( legendLayerStretchUsingCurrentExtent() ) );
}
menu->addAction( QgsApplication::getThemeIcon( "/mActionRemoveLayer.svg" ), tr( "&Remove" ), QgisApp::instance(), SLOT( removeLayer() ) );
// duplicate layer
QAction* duplicateLayersAction = menu->addAction( QgsApplication::getThemeIcon( "/mActionDuplicateLayer.svg" ), tr( "&Duplicate" ), QgisApp::instance(), SLOT( duplicateLayers() ) );
if ( layer && layer->isSpatial() )
{
// set layer scale visibility
menu->addAction( tr( "&Set Layer Scale Visibility" ), QgisApp::instance(), SLOT( setLayerScaleVisibility() ) );
if ( !layer->isInScaleRange( mCanvas->scale() ) )
menu->addAction( tr( "Zoom to &Visible Scale" ), QgisApp::instance(), SLOT( zoomToLayerScale() ) );
// set layer crs
menu->addAction( QgsApplication::getThemeIcon( "/mActionSetCRS.png" ), tr( "Set Layer CRS" ), QgisApp::instance(), SLOT( setLayerCRS() ) );
// assign layer crs to project
menu->addAction( QgsApplication::getThemeIcon( "/mActionSetProjectCRS.png" ), tr( "Set &Project CRS from Layer" ), QgisApp::instance(), SLOT( setProjectCRSFromLayer() ) );
}
// style-related actions
if ( layer && mView->selectedLayerNodes().count() == 1 )
{
QMenu *menuStyleManager = new QMenu( tr( "Styles" ), menu );
QgisApp *app = QgisApp::instance();
menuStyleManager->addAction( tr( "Copy Style" ), app, SLOT( copyStyle() ) );
if ( app->clipboard()->hasFormat( QGSCLIPBOARD_STYLE_MIME ) )
{
menuStyleManager->addAction( tr( "Paste Style" ), app, SLOT( pasteStyle() ) );
}
menuStyleManager->addSeparator();
QgsMapLayerStyleGuiUtils::instance()->addStyleManagerActions( menuStyleManager, layer );
if ( vlayer )
{
const QgsSingleSymbolRendererV2* singleRenderer = dynamic_cast< const QgsSingleSymbolRendererV2* >( vlayer->rendererV2() );
if ( !singleRenderer && vlayer->rendererV2()->embeddedRenderer() )
{
singleRenderer = dynamic_cast< const QgsSingleSymbolRendererV2* >( vlayer->rendererV2()->embeddedRenderer() );
}
if ( singleRenderer && singleRenderer->symbol() )
{
//single symbol renderer, so add set color/edit symbol actions
menuStyleManager->addSeparator();
QgsColorWheel* colorWheel = new QgsColorWheel( menuStyleManager );
colorWheel->setColor( singleRenderer->symbol()->color() );
QgsColorWidgetAction* colorAction = new QgsColorWidgetAction( colorWheel, menuStyleManager, menuStyleManager );
colorAction->setDismissOnColorSelection( false );
connect( colorAction, SIGNAL( colorChanged( const QColor& ) ), this, SLOT( setVectorSymbolColor( const QColor& ) ) );
//store the layer id in action, so we can later retrieve the corresponding layer
colorAction->setProperty( "layerId", vlayer->id() );
menuStyleManager->addAction( colorAction );
//add recent colors action
QList<QgsRecentColorScheme *> recentSchemes;
QgsColorSchemeRegistry::instance()->schemes( recentSchemes );
if ( !recentSchemes.isEmpty() )
{
QgsColorSwatchGridAction* recentColorAction = new QgsColorSwatchGridAction( recentSchemes.at( 0 ), menuStyleManager, "symbology", menuStyleManager );
recentColorAction->setProperty( "layerId", vlayer->id() );
recentColorAction->setDismissOnColorSelection( false );
menuStyleManager->addAction( recentColorAction );
connect( recentColorAction, SIGNAL( colorChanged( const QColor& ) ), this, SLOT( setVectorSymbolColor( const QColor& ) ) );
}
menuStyleManager->addSeparator();
QAction* editSymbolAction = new QAction( tr( "Edit Symbol..." ), menuStyleManager );
//store the layer id in action, so we can later retrieve the corresponding layer
editSymbolAction->setProperty( "layerId", vlayer->id() );
connect( editSymbolAction, SIGNAL( triggered() ), this, SLOT( editVectorSymbol() ) );
menuStyleManager->addAction( editSymbolAction );
}
}
menu->addMenu( menuStyleManager );
}
QMenu *QgsAppLayerTreeViewMenuProvider::createContextMenu()
{
QMenu *menu = new QMenu;
QgsLayerTreeViewDefaultActions *actions = mView->defaultActions();
QModelIndex idx = mView->currentIndex();
if ( !idx.isValid() )
{
// global menu
menu->addAction( actions->actionAddGroup( menu ) );
menu->addAction( QgsApplication::getThemeIcon( QStringLiteral( "/mActionExpandTree.svg" ) ), tr( "&Expand All" ), mView, SLOT( expandAll() ) );
menu->addAction( QgsApplication::getThemeIcon( QStringLiteral( "/mActionCollapseTree.svg" ) ), tr( "&Collapse All" ), mView, SLOT( collapseAll() ) );
menu->addSeparator();
if ( QgisApp::instance()->clipboard()->hasFormat( QGSCLIPBOARD_MAPLAYER_MIME ) )
{
QAction *actionPasteLayerOrGroup = new QAction( QgsApplication::getThemeIcon( QStringLiteral( "/mActionEditPaste.svg" ) ), tr( "Paste Layer/Group" ), menu );
connect( actionPasteLayerOrGroup, &QAction::triggered, QgisApp::instance(), &QgisApp::pasteLayer );
menu->addAction( actionPasteLayerOrGroup );
}
// TODO: update drawing order
}
else if ( QgsLayerTreeNode *node = mView->layerTreeModel()->index2node( idx ) )
{
// layer or group selected
if ( QgsLayerTree::isGroup( node ) )
{
menu->addAction( actions->actionZoomToGroup( mCanvas, menu ) );
menu->addAction( tr( "Copy Group" ), QgisApp::instance(), SLOT( copyLayer() ) );
if ( QgisApp::instance()->clipboard()->hasFormat( QGSCLIPBOARD_MAPLAYER_MIME ) )
{
QAction *actionPasteLayerOrGroup = new QAction( tr( "Paste Layer/Group" ), menu );
connect( actionPasteLayerOrGroup, &QAction::triggered, QgisApp::instance(), &QgisApp::pasteLayer );
menu->addAction( actionPasteLayerOrGroup );
}
menu->addAction( actions->actionRenameGroupOrLayer( menu ) );
menu->addSeparator();
menu->addAction( actions->actionAddGroup( menu ) );
QAction *removeAction = menu->addAction( QgsApplication::getThemeIcon( QStringLiteral( "/mActionRemoveLayer.svg" ) ), tr( "&Remove Group…" ), QgisApp::instance(), SLOT( removeLayer() ) );
removeAction->setEnabled( removeActionEnabled() );
menu->addSeparator();
menu->addAction( QgsApplication::getThemeIcon( QStringLiteral( "/mActionSetCRS.png" ) ),
tr( "&Set Group CRS…" ), QgisApp::instance(), SLOT( legendGroupSetCrs() ) );
menu->addAction( tr( "&Set Group WMS Data…" ), QgisApp::instance(), SLOT( legendGroupSetWmsData() ) );
menu->addSeparator();
menu->addAction( actions->actionMutuallyExclusiveGroup( menu ) );
menu->addAction( actions->actionCheckAndAllChildren( menu ) );
menu->addAction( actions->actionUncheckAndAllChildren( menu ) );
if ( !( mView->selectedNodes( true ).count() == 1 && idx.row() == 0 ) )
{
menu->addAction( actions->actionMoveToTop( menu ) );
}
menu->addSeparator();
if ( mView->selectedNodes( true ).count() >= 2 )
menu->addAction( actions->actionGroupSelected( menu ) );
if ( QgisApp::instance()->clipboard()->hasFormat( QGSCLIPBOARD_STYLE_MIME ) )
{
menu->addAction( tr( "Paste Style" ), QgisApp::instance(), SLOT( applyStyleToGroup() ) );
}
menu->addSeparator();
QMenu *menuExportGroup = new QMenu( tr( "Export" ), menu );
QAction *actionSaveAsDefinitionGroup = new QAction( tr( "Save as Layer Definition File…" ), menuExportGroup );
connect( actionSaveAsDefinitionGroup, &QAction::triggered, QgisApp::instance(), &QgisApp::saveAsLayerDefinition );
menuExportGroup->addAction( actionSaveAsDefinitionGroup );
menu->addMenu( menuExportGroup );
}
else if ( QgsLayerTree::isLayer( node ) )
{
QgsMapLayer *layer = QgsLayerTree::toLayer( node )->layer();
QgsRasterLayer *rlayer = qobject_cast<QgsRasterLayer *>( layer );
QgsVectorLayer *vlayer = qobject_cast<QgsVectorLayer *>( layer );
if ( layer && layer->isSpatial() )
{
menu->addAction( actions->actionZoomToLayer( mCanvas, menu ) );
if ( vlayer )
{
QAction *actionZoomSelected = actions->actionZoomToSelection( mCanvas, menu );
actionZoomSelected->setEnabled( !vlayer->selectedFeatures().isEmpty() );
menu->addAction( actionZoomSelected );
}
menu->addAction( actions->actionShowInOverview( menu ) );
}
if ( vlayer )
menu->addAction( actions->actionShowFeatureCount( menu ) );
QAction *actionCopyLayer = new QAction( tr( "Copy Layer" ), menu );
connect( actionCopyLayer, &QAction::triggered, QgisApp::instance(), &QgisApp::copyLayer );
menu->addAction( actionCopyLayer );
menu->addAction( actions->actionRenameGroupOrLayer( menu ) );
if ( rlayer )
{
menu->addAction( QgsApplication::getThemeIcon( QStringLiteral( "/mActionZoomActual.svg" ) ), tr( "&Zoom to Native Resolution (100%)" ), QgisApp::instance(), SLOT( legendLayerZoomNative() ) );
if ( rlayer->rasterType() != QgsRasterLayer::Palette )
menu->addAction( tr( "&Stretch Using Current Extent" ), QgisApp::instance(), SLOT( legendLayerStretchUsingCurrentExtent() ) );
}
addCustomLayerActions( menu, layer );
if ( layer && layer->type() == QgsMapLayer::VectorLayer && static_cast<QgsVectorLayer *>( layer )->providerType() == QLatin1String( "virtual" ) )
{
menu->addAction( QgsApplication::getThemeIcon( QStringLiteral( "/mActionAddVirtualLayer.svg" ) ), tr( "Edit Virtual Layer…" ), QgisApp::instance(), SLOT( addVirtualLayer() ) );
}
menu->addSeparator();
// duplicate layer
QAction *duplicateLayersAction = menu->addAction( QgsApplication::getThemeIcon( QStringLiteral( "/mActionDuplicateLayer.svg" ) ), tr( "&Duplicate Layer" ), QgisApp::instance(), SLOT( duplicateLayers() ) );
QAction *removeAction = menu->addAction( QgsApplication::getThemeIcon( QStringLiteral( "/mActionRemoveLayer.svg" ) ), tr( "&Remove Layer…" ), QgisApp::instance(), SLOT( removeLayer() ) );
removeAction->setEnabled( removeActionEnabled() );
menu->addSeparator();
if ( node->parent() != mView->layerTreeModel()->rootGroup() )
menu->addAction( actions->actionMoveOutOfGroup( menu ) );
if ( !( mView->selectedNodes( true ).count() == 1 && idx.row() == 0 ) )
{
menu->addAction( actions->actionMoveToTop( menu ) );
}
QAction *checkAll = actions->actionCheckAndAllParents( menu );
if ( checkAll )
menu->addAction( checkAll );
if ( mView->selectedNodes( true ).count() >= 2 )
menu->addAction( actions->actionGroupSelected( menu ) );
menu->addSeparator();
if ( vlayer )
{
QAction *toggleEditingAction = QgisApp::instance()->actionToggleEditing();
QAction *saveLayerEditsAction = QgisApp::instance()->actionSaveActiveLayerEdits();
QAction *allEditsAction = QgisApp::instance()->actionAllEdits();
// attribute table
menu->addAction( QgsApplication::getThemeIcon( QStringLiteral( "/mActionOpenTable.svg" ) ), tr( "&Open Attribute Table" ),
QgisApp::instance(), SLOT( attributeTable() ) );
// allow editing
int cap = vlayer->dataProvider()->capabilities();
if ( cap & QgsVectorDataProvider::EditingCapabilities )
{
if ( toggleEditingAction )
{
menu->addAction( toggleEditingAction );
toggleEditingAction->setChecked( vlayer->isEditable() );
toggleEditingAction->setEnabled( true );
}
if ( saveLayerEditsAction && vlayer->isModified() )
{
menu->addAction( saveLayerEditsAction );
}
}
if ( allEditsAction->isEnabled() )
menu->addAction( allEditsAction );
// disable duplication of memory layers
if ( vlayer->storageType() == QLatin1String( "Memory storage" ) && mView->selectedLayerNodes().count() == 1 )
duplicateLayersAction->setEnabled( false );
if ( vlayer->dataProvider()->supportsSubsetString() )
{
QAction *action = menu->addAction( tr( "&Filter…" ), QgisApp::instance(), SLOT( layerSubsetString() ) );
action->setEnabled( !vlayer->isEditable() );
}
}
menu->addSeparator();
if ( layer && layer->isSpatial() )
{
// set layer scale visibility
menu->addAction( tr( "&Set Layer Scale Visibility…" ), QgisApp::instance(), SLOT( setLayerScaleVisibility() ) );
if ( !layer->isInScaleRange( mCanvas->scale() ) )
menu->addAction( tr( "Zoom to &Visible Scale" ), QgisApp::instance(), SLOT( zoomToLayerScale() ) );
QMenu *menuSetCRS = new QMenu( tr( "Set CRS" ), menu );
// set layer crs
QAction *actionSetLayerCrs = new QAction( tr( "Set Layer CRS…" ), menuSetCRS );
connect( actionSetLayerCrs, &QAction::triggered, QgisApp::instance(), &QgisApp::setLayerCrs );
menuSetCRS->addAction( actionSetLayerCrs );
// assign layer crs to project
QAction *actionSetProjectCrs = new QAction( tr( "Set &Project CRS from Layer" ), menuSetCRS );
connect( actionSetProjectCrs, &QAction::triggered, QgisApp::instance(), &QgisApp::setProjectCrsFromLayer );
menuSetCRS->addAction( actionSetProjectCrs );
menu->addMenu( menuSetCRS );
}
menu->addSeparator();
if ( vlayer )
{
// save as vector file
QMenu *menuExportVector = new QMenu( tr( "Export" ), menu );
QAction *actionSaveAs = new QAction( tr( "Save Features As…" ), menuExportVector );
connect( actionSaveAs, &QAction::triggered, QgisApp::instance(), [ = ] { QgisApp::instance()->saveAsFile(); } );
menuExportVector->addAction( actionSaveAs );
QAction *actionSaveSelectedFeaturesAs = new QAction( tr( "Save Selected Features As…" ), menuExportVector );
connect( actionSaveSelectedFeaturesAs, &QAction::triggered, QgisApp::instance(), [ = ] { QgisApp::instance()->saveAsFile( nullptr, true ); } );
actionSaveSelectedFeaturesAs->setEnabled( vlayer->selectedFeatureCount() > 0 );
menuExportVector->addAction( actionSaveSelectedFeaturesAs );
QAction *actionSaveAsDefinitionLayer = new QAction( tr( "Save as Layer Definition File…" ), menuExportVector );
connect( actionSaveAsDefinitionLayer, &QAction::triggered, QgisApp::instance(), &QgisApp::saveAsLayerDefinition );
menuExportVector->addAction( actionSaveAsDefinitionLayer );
if ( vlayer->isSpatial() )
{
QAction *actionSaveStyle = new QAction( tr( "Save as QGIS Layer Style File…" ), menuExportVector );
connect( actionSaveStyle, &QAction::triggered, QgisApp::instance(), [ = ] { QgisApp::instance()->saveStyleFile(); } );
menuExportVector->addAction( actionSaveStyle );
}
menu->addMenu( menuExportVector );
}
else if ( rlayer )
{
QMenu *menuExportRaster = new QMenu( tr( "Export" ), menu );
QAction *actionSaveAs = new QAction( tr( "Save As…" ), menuExportRaster );
QAction *actionSaveAsDefinitionLayer = new QAction( tr( "Save as Layer Definition File…" ), menuExportRaster );
QAction *actionSaveStyle = new QAction( tr( "Save as QGIS Layer Style File…" ), menuExportRaster );
connect( actionSaveAs, &QAction::triggered, QgisApp::instance(), [ = ] { QgisApp::instance()->saveAsFile(); } );
menuExportRaster->addAction( actionSaveAs );
connect( actionSaveAsDefinitionLayer, &QAction::triggered, QgisApp::instance(), &QgisApp::saveAsLayerDefinition );
menuExportRaster->addAction( actionSaveAsDefinitionLayer );
connect( actionSaveStyle, &QAction::triggered, QgisApp::instance(), [ = ] { QgisApp::instance()->saveStyleFile(); } );
menuExportRaster->addAction( actionSaveStyle );
menu->addMenu( menuExportRaster );
}
else if ( layer && layer->type() == QgsMapLayer::PluginLayer && mView->selectedLayerNodes().count() == 1 )
{
// disable duplication of plugin layers
duplicateLayersAction->setEnabled( false );
}
menu->addSeparator();
// style-related actions
if ( layer && mView->selectedLayerNodes().count() == 1 )
{
menu->addSeparator();
QMenu *menuStyleManager = new QMenu( tr( "Styles" ), menu );
QgisApp *app = QgisApp::instance();
menuStyleManager->addAction( tr( "Copy Style" ), app, SLOT( copyStyle() ) );
if ( app->clipboard()->hasFormat( QGSCLIPBOARD_STYLE_MIME ) )
{
menuStyleManager->addAction( tr( "Paste Style" ), app, SLOT( pasteStyle() ) );
}
menuStyleManager->addSeparator();
QgsMapLayerStyleGuiUtils::instance()->addStyleManagerActions( menuStyleManager, layer );
if ( vlayer )
{
const QgsSingleSymbolRenderer *singleRenderer = dynamic_cast< const QgsSingleSymbolRenderer * >( vlayer->renderer() );
if ( !singleRenderer && vlayer->renderer() && vlayer->renderer()->embeddedRenderer() )
{
singleRenderer = dynamic_cast< const QgsSingleSymbolRenderer * >( vlayer->renderer()->embeddedRenderer() );
}
if ( singleRenderer && singleRenderer->symbol() )
{
//single symbol renderer, so add set color/edit symbol actions
menuStyleManager->addSeparator();
QgsColorWheel *colorWheel = new QgsColorWheel( menuStyleManager );
colorWheel->setColor( singleRenderer->symbol()->color() );
QgsColorWidgetAction *colorAction = new QgsColorWidgetAction( colorWheel, menuStyleManager, menuStyleManager );
colorAction->setDismissOnColorSelection( false );
connect( colorAction, &QgsColorWidgetAction::colorChanged, this, &QgsAppLayerTreeViewMenuProvider::setVectorSymbolColor );
//store the layer id in action, so we can later retrieve the corresponding layer
colorAction->setProperty( "layerId", vlayer->id() );
menuStyleManager->addAction( colorAction );
//add recent colors action
QList<QgsRecentColorScheme *> recentSchemes;
QgsApplication::colorSchemeRegistry()->schemes( recentSchemes );
if ( !recentSchemes.isEmpty() )
{
QgsColorSwatchGridAction *recentColorAction = new QgsColorSwatchGridAction( recentSchemes.at( 0 ), menuStyleManager, QStringLiteral( "symbology" ), menuStyleManager );
recentColorAction->setProperty( "layerId", vlayer->id() );
recentColorAction->setDismissOnColorSelection( false );
menuStyleManager->addAction( recentColorAction );
connect( recentColorAction, &QgsColorSwatchGridAction::colorChanged, this, &QgsAppLayerTreeViewMenuProvider::setVectorSymbolColor );
}
menuStyleManager->addSeparator();
QAction *editSymbolAction = new QAction( tr( "Edit Symbol…" ), menuStyleManager );
//store the layer id in action, so we can later retrieve the corresponding layer
editSymbolAction->setProperty( "layerId", vlayer->id() );
connect( editSymbolAction, &QAction::triggered, this, &QgsAppLayerTreeViewMenuProvider::editVectorSymbol );
menuStyleManager->addAction( editSymbolAction );
}
}
menu->addMenu( menuStyleManager );
}
else
{
if ( QgisApp::instance()->clipboard()->hasFormat( QGSCLIPBOARD_STYLE_MIME ) )
{
menu->addAction( tr( "Paste Style" ), QgisApp::instance(), SLOT( applyStyleToGroup() ) );
}
}
if ( layer && QgsProject::instance()->layerIsEmbedded( layer->id() ).isEmpty() )
menu->addAction( tr( "&Properties…" ), QgisApp::instance(), SLOT( layerProperties() ) );
}
}
else if ( QgsLayerTreeModelLegendNode *node = mView->layerTreeModel()->index2legendNode( idx ) )
{
if ( QgsSymbolLegendNode *symbolNode = dynamic_cast< QgsSymbolLegendNode * >( node ) )
{
// symbology item
if ( symbolNode->flags() & Qt::ItemIsUserCheckable )
{
menu->addAction( QgsApplication::getThemeIcon( QStringLiteral( "/mActionShowAllLayers.svg" ) ), tr( "&Show All Items" ),
symbolNode, SLOT( checkAllItems() ) );
menu->addAction( QgsApplication::getThemeIcon( QStringLiteral( "/mActionHideAllLayers.svg" ) ), tr( "&Hide All Items" ),
symbolNode, SLOT( uncheckAllItems() ) );
menu->addSeparator();
}
if ( symbolNode->symbol() )
{
QgsColorWheel *colorWheel = new QgsColorWheel( menu );
colorWheel->setColor( symbolNode->symbol()->color() );
QgsColorWidgetAction *colorAction = new QgsColorWidgetAction( colorWheel, menu, menu );
colorAction->setDismissOnColorSelection( false );
connect( colorAction, &QgsColorWidgetAction::colorChanged, this, &QgsAppLayerTreeViewMenuProvider::setSymbolLegendNodeColor );
//store the layer id and rule key in action, so we can later retrieve the corresponding
//legend node, if it still exists
colorAction->setProperty( "layerId", symbolNode->layerNode()->layerId() );
colorAction->setProperty( "ruleKey", symbolNode->data( QgsLayerTreeModelLegendNode::RuleKeyRole ).toString() );
menu->addAction( colorAction );
//add recent colors action
QList<QgsRecentColorScheme *> recentSchemes;
QgsApplication::colorSchemeRegistry()->schemes( recentSchemes );
if ( !recentSchemes.isEmpty() )
{
QgsColorSwatchGridAction *recentColorAction = new QgsColorSwatchGridAction( recentSchemes.at( 0 ), menu, QStringLiteral( "symbology" ), menu );
recentColorAction->setProperty( "layerId", symbolNode->layerNode()->layerId() );
recentColorAction->setProperty( "ruleKey", symbolNode->data( QgsLayerTreeModelLegendNode::RuleKeyRole ).toString() );
recentColorAction->setDismissOnColorSelection( false );
menu->addAction( recentColorAction );
connect( recentColorAction, &QgsColorSwatchGridAction::colorChanged, this, &QgsAppLayerTreeViewMenuProvider::setSymbolLegendNodeColor );
}
menu->addSeparator();
}
QAction *editSymbolAction = new QAction( tr( "Edit Symbol…" ), menu );
//store the layer id and rule key in action, so we can later retrieve the corresponding
//legend node, if it still exists
editSymbolAction->setProperty( "layerId", symbolNode->layerNode()->layerId() );
editSymbolAction->setProperty( "ruleKey", symbolNode->data( QgsLayerTreeModelLegendNode::RuleKeyRole ).toString() );
connect( editSymbolAction, &QAction::triggered, this, &QgsAppLayerTreeViewMenuProvider::editSymbolLegendNodeSymbol );
menu->addAction( editSymbolAction );
}
}
return menu;
}
void QgsDxfExport::writeEntities()
{
startSection();
writeGroup( 2, "ENTITIES" );
//label engine
QgsDxfPalLabeling labelEngine( this, mExtent.isEmpty() ? dxfExtent() : mExtent, mSymbologyScaleDenominator, mMapUnits );
QgsRenderContext& ctx = labelEngine.renderContext();
//iterate through the maplayers
QList< QgsMapLayer* >::iterator layerIt = mLayers.begin();
for ( ; layerIt != mLayers.end(); ++layerIt )
{
QgsVectorLayer* vl = qobject_cast<QgsVectorLayer*>( *layerIt );
if ( !vl || !layerIsScaleBasedVisible( vl ) )
{
continue;
}
QgsSymbolV2RenderContext sctx( ctx, QgsSymbolV2::MM , 1.0, false, 0, 0 );
QgsFeatureRendererV2* renderer = vl->rendererV2();
renderer->startRender( ctx, vl->pendingFields() );
QStringList attributes = renderer->usedAttributes();
bool labelLayer = ( labelEngine.prepareLayer( vl, attributes, ctx ) != 0 );
if ( mSymbologyExport == QgsDxfExport::SymbolLayerSymbology && ( renderer->capabilities() & QgsFeatureRendererV2::SymbolLevels ) &&
renderer->usingSymbolLevels() )
{
writeEntitiesSymbolLevels( vl );
renderer->stopRender( ctx );
continue;
}
QgsFeatureRequest freq = QgsFeatureRequest().setSubsetOfAttributes(
attributes, vl->pendingFields() );
if ( !mExtent.isEmpty() )
{
freq.setFilterRect( mExtent );
}
QgsFeatureIterator featureIt = vl->getFeatures( freq );
QgsFeature fet;
while ( featureIt.nextFeature( fet ) )
{
sctx.setFeature( &fet );
if ( mSymbologyExport == NoSymbology )
{
addFeature( sctx, dxfLayerName( vl->name() ), 0, 0 ); //no symbology at all
}
else
{
if ( !renderer )
{
continue;
}
QgsSymbolV2List symbolList = renderer->symbolsForFeature( fet );
if ( symbolList.size() < 1 )
{
continue;
}
if ( mSymbologyExport == QgsDxfExport::SymbolLayerSymbology ) //symbol layer symbology, but layer does not use symbol levels
{
QgsSymbolV2List::iterator symbolIt = symbolList.begin();
for ( ; symbolIt != symbolList.end(); ++symbolIt )
{
int nSymbolLayers = ( *symbolIt )->symbolLayerCount();
for ( int i = 0; i < nSymbolLayers; ++i )
{
addFeature( sctx, dxfLayerName( vl->name() ), ( *symbolIt )->symbolLayer( i ), *symbolIt );
}
}
}
else
{
//take first symbollayer from first symbol
QgsSymbolV2* s = symbolList.first();
if ( !s || s->symbolLayerCount() < 1 )
{
continue;
}
addFeature( sctx, dxfLayerName( vl->name() ), s->symbolLayer( 0 ), s );
}
if ( labelLayer )
{
labelEngine.registerFeature( vl->id(), fet, ctx );
}
}
}
renderer->stopRender( ctx );
}
labelEngine.drawLabeling( ctx );
endSection();
}
QDomDocument QgsWFSServer::describeFeatureType()
{
QgsDebugMsg( "Entering." );
QDomDocument doc;
//xsd:schema
QDomElement schemaElement = doc.createElement( "schema"/*xsd:schema*/ );
schemaElement.setAttribute( "xmlns", "http://www.w3.org/2001/XMLSchema" );
schemaElement.setAttribute( "xmlns:xsd", "http://www.w3.org/2001/XMLSchema" );
schemaElement.setAttribute( "xmlns:ogc", "http://www.opengis.net/ogc" );
schemaElement.setAttribute( "xmlns:gml", "http://www.opengis.net/gml" );
schemaElement.setAttribute( "xmlns:qgs", "http://www.qgis.org/gml" );
schemaElement.setAttribute( "targetNamespace", "http://www.qgis.org/gml" );
doc.appendChild( schemaElement );
//xsd:import
QDomElement importElement = doc.createElement( "import"/*xsd:import*/ );
importElement.setAttribute( "namespace", "http://www.opengis.net/gml" );
importElement.setAttribute( "schemaLocation", "http://schemas.opengis.net/gml/2.1.2/feature.xsd" );
schemaElement.appendChild( importElement );
//read TYPENAME
QString typeName;
QMap<QString, QString>::const_iterator type_name_it = mParameterMap.find( "TYPENAME" );
if ( type_name_it != mParameterMap.end() )
{
typeName = type_name_it.value();
}
else
{
return doc;
}
QStringList wfsLayersId = mConfigParser->wfsLayers();
QMap< QString, QMap< int, QString > > aliasInfo = mConfigParser->layerAliasInfo();
QMap< QString, QSet<QString> > hiddenAttributes = mConfigParser->hiddenAttributes();
QList<QgsMapLayer*> layerList;
QgsMapLayer* currentLayer = 0;
layerList = mConfigParser->mapLayerFromStyle( typeName, "" );
currentLayer = layerList.at( 0 );
QgsVectorLayer* layer = dynamic_cast<QgsVectorLayer*>( currentLayer );
if ( layer && wfsLayersId.contains( layer->id() ) )
{
//is there alias info for this vector layer?
QMap< int, QString > layerAliasInfo;
QMap< QString, QMap< int, QString > >::const_iterator aliasIt = aliasInfo.find( currentLayer->id() );
if ( aliasIt != aliasInfo.constEnd() )
{
layerAliasInfo = aliasIt.value();
}
//hidden attributes for this layer
QSet<QString> layerHiddenAttributes;
QMap< QString, QSet<QString> >::const_iterator hiddenIt = hiddenAttributes.find( currentLayer->id() );
if ( hiddenIt != hiddenAttributes.constEnd() )
{
layerHiddenAttributes = hiddenIt.value();
}
//do a select with searchRect and go through all the features
QgsVectorDataProvider* provider = layer->dataProvider();
if ( !provider )
{
return doc;
}
typeName = typeName.replace( QString( " " ), QString( "_" ) );
//xsd:element
QDomElement elementElem = doc.createElement( "element"/*xsd:element*/ );
elementElem.setAttribute( "name", typeName );
elementElem.setAttribute( "type", "qgs:" + typeName + "Type" );
elementElem.setAttribute( "substitutionGroup", "gml:_Feature" );
schemaElement.appendChild( elementElem );
//xsd:complexType
QDomElement complexTypeElem = doc.createElement( "complexType"/*xsd:complexType*/ );
complexTypeElem.setAttribute( "name", typeName + "Type" );
schemaElement.appendChild( complexTypeElem );
//xsd:complexType
QDomElement complexContentElem = doc.createElement( "complexContent"/*xsd:complexContent*/ );
complexTypeElem.appendChild( complexContentElem );
//xsd:extension
QDomElement extensionElem = doc.createElement( "extension"/*xsd:extension*/ );
extensionElem.setAttribute( "base", "gml:AbstractFeatureType" );
complexContentElem.appendChild( extensionElem );
//xsd:sequence
QDomElement sequenceElem = doc.createElement( "sequence"/*xsd:sequence*/ );
extensionElem.appendChild( sequenceElem );
//xsd:element
QDomElement geomElem = doc.createElement( "element"/*xsd:element*/ );
geomElem.setAttribute( "name", "geometry" );
geomElem.setAttribute( "type", "gml:GeometryPropertyType" );
geomElem.setAttribute( "minOccurs", "0" );
geomElem.setAttribute( "maxOccurs", "1" );
sequenceElem.appendChild( geomElem );
const QgsFieldMap& fields = provider->fields();
for ( QgsFieldMap::const_iterator it = fields.begin(); it != fields.end(); ++it )
{
QString attributeName = it.value().name();
//skip attribute if it has edit type 'hidden'
if ( layerHiddenAttributes.contains( attributeName ) )
{
continue;
}
//xsd:element
QDomElement geomElem = doc.createElement( "element"/*xsd:element*/ );
geomElem.setAttribute( "name", attributeName );
if ( it.value().type() == 2 )
geomElem.setAttribute( "type", "integer" );
else if ( it.value().type() == 6 )
geomElem.setAttribute( "type", "double" );
else
geomElem.setAttribute( "type", "string" );
sequenceElem.appendChild( geomElem );
//check if the attribute name should be replaced with an alias
QMap<int, QString>::const_iterator aliasIt = layerAliasInfo.find( it.key() );
if ( aliasIt != layerAliasInfo.constEnd() )
{
geomElem.setAttribute( "alias", aliasIt.value() );
}
}
}
return doc;
}
void QgsGeometryCheckerSetupTab::runChecks()
{
// Get selected layer
QList<QgsVectorLayer *> layers = getSelectedLayers();
if ( layers.isEmpty() )
return;
if ( ui.radioButtonOutputNew->isChecked() )
{
for ( QgsVectorLayer *layer : layers )
{
if ( layer->dataProvider()->dataSourceUri().startsWith( ui.lineEditOutputDirectory->text() ) )
{
QMessageBox::critical( this, tr( "Invalid Output Directory" ), tr( "The chosen output directory contains one or more input layers." ) );
return;
}
}
}
QgsVectorLayer *lineLayerCheckLayer = ui.comboLineLayerIntersection->isEnabled() ? dynamic_cast<QgsVectorLayer *>( QgsProject::instance()->mapLayer( ui.comboLineLayerIntersection->currentData().toString() ) ) : nullptr;
QgsVectorLayer *followBoundaryCheckLayer = ui.comboBoxFollowBoundaries->isEnabled() ? dynamic_cast<QgsVectorLayer *>( QgsProject::instance()->mapLayer( ui.comboBoxFollowBoundaries->currentData().toString() ) ) : nullptr;
if ( layers.contains( lineLayerCheckLayer ) || layers.contains( followBoundaryCheckLayer ) )
{
QMessageBox::critical( this, tr( "Error" ), tr( "The test layer set contains a layer selected for a topology check." ) );
return;
}
for ( QgsVectorLayer *layer : layers )
{
if ( layer->isEditable() )
{
QMessageBox::critical( this, tr( "Editable Input Layer" ), tr( "Input layer are not allowed to be in editing mode." ) );
return;
}
}
bool selectedOnly = ui.checkBoxInputSelectedOnly->isChecked();
// Set window busy
setCursor( Qt::WaitCursor );
mRunButton->setEnabled( false );
ui.labelStatus->setText( tr( "<b>Preparing output...</b>" ) );
ui.labelStatus->show();
QApplication::processEvents( QEventLoop::ExcludeUserInputEvents );
QList<QgsVectorLayer *> processLayers;
if ( ui.radioButtonOutputNew->isChecked() )
{
// Get output directory and file extension
QDir outputDir = QDir( ui.lineEditOutputDirectory->text() );
QString outputDriverName = ui.comboBoxOutputFormat->currentText();
QgsVectorFileWriter::MetaData metadata;
if ( !QgsVectorFileWriter::driverMetadata( outputDriverName, metadata ) )
{
QMessageBox::critical( this, tr( "Unknown Output Format" ), tr( "The specified output format cannot be recognized." ) );
mRunButton->setEnabled( true );
ui.labelStatus->hide();
unsetCursor();
return;
}
QString outputExtension = metadata.ext;
// List over input layers, check which existing project layers need to be removed and create output layers
QString filenamePrefix = ui.lineEditFilenamePrefix->text();
QSettings().setValue( "/geometry_checker/previous_values/filename_prefix", filenamePrefix );
QStringList toRemove;
QStringList createErrors;
for ( QgsVectorLayer *layer : layers )
{
QString outputPath = outputDir.absoluteFilePath( filenamePrefix + layer->name() + "." + outputExtension );
// Remove existing layer with same uri from project
for ( QgsVectorLayer *projectLayer : QgsProject::instance()->layers<QgsVectorLayer *>() )
{
if ( projectLayer->dataProvider()->dataSourceUri().startsWith( outputPath ) )
{
toRemove.append( projectLayer->id() );
}
}
// Create output layer
QString errMsg;
QgsVectorFileWriter::WriterError err = QgsVectorFileWriter::writeAsVectorFormat( layer, outputPath, layer->dataProvider()->encoding(), layer->crs(), outputDriverName, selectedOnly, &errMsg );
if ( err != QgsVectorFileWriter::NoError )
{
createErrors.append( errMsg );
continue;
}
QgsVectorLayer *newlayer = new QgsVectorLayer( outputPath, QFileInfo( outputPath ).completeBaseName(), QStringLiteral( "ogr" ) );
if ( selectedOnly )
{
QgsFeature feature;
// Get features to select (only selected features were written up to this point)
QgsFeatureIds selectedFeatures = newlayer->allFeatureIds();
// Write non-selected feature ids
QgsFeatureList features;
QgsFeatureIterator it = layer->getFeatures();
while ( it.nextFeature( feature ) )
{
if ( !layer->selectedFeatureIds().contains( feature.id() ) )
{
features.append( feature );
}
}
newlayer->dataProvider()->addFeatures( features );
// Set selected features
newlayer->selectByIds( selectedFeatures );
}
processLayers.append( newlayer );
}
// Remove layers from project
if ( !toRemove.isEmpty() )
{
QgsProject::instance()->removeMapLayers( toRemove );
}
// Error if an output layer could not be created
if ( !createErrors.isEmpty() )
{
QMessageBox::critical( this, tr( "Layer Creation Failed" ), tr( "Failed to create one or moure output layers:\n%1" ).arg( createErrors.join( "\n" ) ) );
mRunButton->setEnabled( true );
ui.labelStatus->hide();
unsetCursor();
return;
}
}
else
{
processLayers = layers;
}
// Check if output layers are editable
QList<QgsVectorLayer *> nonEditableLayers;
for ( QgsVectorLayer *layer : processLayers )
{
if ( ( layer->dataProvider()->capabilities() & QgsVectorDataProvider::ChangeGeometries ) == 0 )
{
nonEditableLayers.append( layer );
}
}
if ( !nonEditableLayers.isEmpty() )
{
QStringList nonEditableLayerNames;
for ( QgsVectorLayer *layer : nonEditableLayers )
{
nonEditableLayerNames.append( layer->name() );
}
if ( QMessageBox::Yes != QMessageBox::question( this, tr( "Non-editable Output Layers" ), tr( "The following output layers are ina format that does not support editing features:\n%1\n\nThe geometry check can be performed, but it will not be possible to fix any errors. Do you want to continue?" ).arg( nonEditableLayerNames.join( "\n" ) ), QMessageBox::Yes, QMessageBox::No ) )
{
if ( ui.radioButtonOutputNew->isChecked() )
{
for ( QgsVectorLayer *layer : processLayers )
{
QString layerPath = layer->dataProvider()->dataSourceUri();
delete layer;
if ( ui.comboBoxOutputFormat->currentText() == QLatin1String( "ESRI Shapefile" ) )
{
QgsVectorFileWriter::deleteShapeFile( layerPath );
}
else
{
QFile( layerPath ).remove();
}
}
mRunButton->setEnabled( true );
ui.labelStatus->hide();
unsetCursor();
}
return;
}
}
// Setup checker
ui.labelStatus->setText( tr( "<b>Building spatial index...</b>" ) );
QApplication::processEvents( QEventLoop::ExcludeUserInputEvents );
QMap<QString, QgsFeaturePool *> featurePools;
for ( QgsVectorLayer *layer : processLayers )
{
double layerToMapUntis = mIface->mapCanvas()->mapSettings().layerToMapUnits( layer );
QgsCoordinateTransform layerToMapTransform = QgsCoordinateTransformCache::instance()->transform( layer->crs().authid(), mIface->mapCanvas()->mapSettings().destinationCrs().authid() );
featurePools.insert( layer->id(), new QgsFeaturePool( layer, layerToMapUntis, layerToMapTransform, selectedOnly ) );
}
// LineLayerIntersection check is enabled, make sure there is also a feature pool for that layer
if ( ui.checkLineLayerIntersection->isChecked() && !featurePools.keys().contains( ui.comboLineLayerIntersection->currentData().toString() ) )
{
QgsVectorLayer *layer = dynamic_cast<QgsVectorLayer *>( QgsProject::instance()->mapLayer( ui.comboLineLayerIntersection->currentData().toString() ) );
Q_ASSERT( layer );
double layerToMapUntis = mIface->mapCanvas()->mapSettings().layerToMapUnits( layer );
QgsCoordinateTransform layerToMapTransform = QgsCoordinateTransformCache::instance()->transform( layer->crs().authid(), mIface->mapCanvas()->mapSettings().destinationCrs().authid() );
featurePools.insert( layer->id(), new QgsFeaturePool( layer, layerToMapUntis, layerToMapTransform, selectedOnly ) );
}
QgsGeometryCheckerContext *context = new QgsGeometryCheckerContext( ui.spinBoxTolerance->value(), mIface->mapCanvas()->mapSettings().destinationCrs().authid(), featurePools );
QList<QgsGeometryCheck *> checks;
for ( const QgsGeometryCheckFactory *factory : QgsGeometryCheckFactoryRegistry::getCheckFactories() )
{
QgsGeometryCheck *check = factory->createInstance( context, ui );
if ( check )
{
checks.append( check );
}
}
QgsGeometryChecker *checker = new QgsGeometryChecker( checks, context );
emit checkerStarted( checker );
if ( ui.radioButtonOutputNew->isChecked() )
{
QList<QgsMapLayer *> addLayers;
for ( QgsVectorLayer *layer : processLayers )
{
addLayers.append( layer );
}
QgsProject::instance()->addMapLayers( addLayers );
}
// Run
ui.buttonBox->addButton( mAbortButton, QDialogButtonBox::ActionRole );
mRunButton->hide();
ui.progressBar->setRange( 0, 0 );
ui.labelStatus->hide();
ui.progressBar->show();
ui.widgetInputs->setEnabled( false );
QEventLoop evLoop;
QFutureWatcher<void> futureWatcher;
connect( checker, &QgsGeometryChecker::progressValue, ui.progressBar, &QProgressBar::setValue );
connect( &futureWatcher, &QFutureWatcherBase::finished, &evLoop, &QEventLoop::quit );
connect( mAbortButton, &QAbstractButton::clicked, &futureWatcher, &QFutureWatcherBase::cancel );
connect( mAbortButton, &QAbstractButton::clicked, this, &QgsGeometryCheckerSetupTab::showCancelFeedback );
int maxSteps = 0;
futureWatcher.setFuture( checker->execute( &maxSteps ) );
ui.progressBar->setRange( 0, maxSteps );
evLoop.exec();
// Restore window
unsetCursor();
mAbortButton->setEnabled( true );
ui.buttonBox->removeButton( mAbortButton );
mRunButton->setEnabled( true );
mRunButton->show();
ui.progressBar->hide();
ui.labelStatus->hide();
ui.widgetInputs->setEnabled( true );
// Show result
emit checkerFinished( !futureWatcher.isCanceled() );
}
int QgsWFSServer::getFeature( QgsRequestHandler& request, const QString& format )
{
QgsDebugMsg( "Info format is:" + format );
//read TYPENAME
QMap<QString, QString>::const_iterator type_name_it = mParameterMap.find( "TYPENAME" );
if ( type_name_it != mParameterMap.end() )
{
mTypeName = type_name_it.value();
}
else
{
return 1;
}
QStringList wfsLayersId = mConfigParser->wfsLayers();
QMap< QString, QMap< int, QString > > aliasInfo = mConfigParser->layerAliasInfo();
QMap< QString, QSet<QString> > hiddenAttributes = mConfigParser->hiddenAttributes();
QList<QgsMapLayer*> layerList;
QgsMapLayer* currentLayer = 0;
layerList = mConfigParser->mapLayerFromStyle( mTypeName, "" );
currentLayer = layerList.at( 0 );
QgsVectorLayer* layer = dynamic_cast<QgsVectorLayer*>( currentLayer );
if ( layer && wfsLayersId.contains( layer->id() ) )
{
//is there alias info for this vector layer?
QMap< int, QString > layerAliasInfo;
QMap< QString, QMap< int, QString > >::const_iterator aliasIt = aliasInfo.find( currentLayer->id() );
if ( aliasIt != aliasInfo.constEnd() )
{
layerAliasInfo = aliasIt.value();
}
//hidden attributes for this layer
QSet<QString> layerHiddenAttributes;
QMap< QString, QSet<QString> >::const_iterator hiddenIt = hiddenAttributes.find( currentLayer->id() );
if ( hiddenIt != hiddenAttributes.constEnd() )
{
layerHiddenAttributes = hiddenIt.value();
}
//do a select with searchRect and go through all the features
QgsVectorDataProvider* provider = layer->dataProvider();
if ( !provider )
{
return 2;
}
QgsFeature feature;
QgsAttributeMap featureAttributes;
const QgsFieldMap& fields = provider->fields();
//map extent
QgsRectangle searchRect = layer->extent();
//read FEATUREDID
bool fidOk = false;
QString fid;
QMap<QString, QString>::const_iterator fidIt = mParameterMap.find( "FEATUREID" );
if ( fidIt != mParameterMap.end() )
{
fidOk = true;
fid = fidIt.value();
}
//read FILTER
bool filterOk = false;
QDomDocument filter;
QMap<QString, QString>::const_iterator filterIt = mParameterMap.find( "FILTER" );
if ( filterIt != mParameterMap.end() )
{
try
{
QString errorMsg;
if ( !filter.setContent( filterIt.value(), true, &errorMsg ) )
{
QgsDebugMsg( "soap request parse error" );
QgsDebugMsg( "error message: " + errorMsg );
QgsDebugMsg( "the xml string was:" );
QgsDebugMsg( filterIt.value() );
}
else
{
filterOk = true;
}
}
catch ( QgsMapServiceException& e )
{
Q_UNUSED( e );
filterOk = false;
}
}
bool conversionSuccess;
double minx, miny, maxx, maxy;
bool bboxOk = false;
//read BBOX
QMap<QString, QString>::const_iterator bbIt = mParameterMap.find( "BBOX" );
if ( bbIt == mParameterMap.end() )
{
minx = 0; miny = 0; maxx = 0; maxy = 0;
}
else
{
bboxOk = true;
QString bbString = bbIt.value();
minx = bbString.section( ",", 0, 0 ).toDouble( &conversionSuccess );
if ( !conversionSuccess ) {bboxOk = false;}
miny = bbString.section( ",", 1, 1 ).toDouble( &conversionSuccess );
if ( !conversionSuccess ) {bboxOk = false;}
maxx = bbString.section( ",", 2, 2 ).toDouble( &conversionSuccess );
if ( !conversionSuccess ) {bboxOk = false;}
maxy = bbString.section( ",", 3, 3 ).toDouble( &conversionSuccess );
if ( !conversionSuccess ) {bboxOk = false;}
}
//read MAXFEATURES
long maxFeat = layer->featureCount();
long featureCounter = 0;
QMap<QString, QString>::const_iterator mfIt = mParameterMap.find( "MAXFEATURES" );
if ( mfIt != mParameterMap.end() )
{
QString mfString = mfIt.value();
bool mfOk;
maxFeat = mfString.toLong( &mfOk, 10 );
if ( !mfOk ) { maxFeat = layer->featureCount(); }
}
//read PROPERTYNAME
mWithGeom = true;
QgsAttributeList attrIndexes = provider->attributeIndexes();
QMap<QString, QString>::const_iterator pnIt = mParameterMap.find( "PROPERTYNAME" );
if ( pnIt != mParameterMap.end() )
{
QStringList attrList = pnIt.value().split( "," );
if ( attrList.size() > 0 )
{
mWithGeom = false;
QStringList::const_iterator alstIt;
QList<int> idxList;
QMap<QString, int> fieldMap = provider->fieldNameMap();
QMap<QString, int>::const_iterator fieldIt;
QString fieldName;
for ( alstIt = attrList.begin(); alstIt != attrList.end(); ++alstIt )
{
fieldName = *alstIt;
fieldIt = fieldMap.find( fieldName );
if ( fieldIt != fieldMap.end() )
{
idxList.append( fieldIt.value() );
}
else if ( fieldName == "geometry" )
{
mWithGeom = true;
}
}
if ( idxList.size() > 0 || mWithGeom )
{
attrIndexes = idxList;
}
else
{
mWithGeom = true;
}
}
}
QgsCoordinateReferenceSystem layerCrs = layer->crs();
startGetFeature( request, format );
if ( fidOk )
{
provider->featureAtId( fid.toInt(), feature, mWithGeom, attrIndexes );
sendGetFeature( request, format, &feature, 0, layerCrs, fields, layerHiddenAttributes );
}
else if ( filterOk )
{
provider->select( attrIndexes, searchRect, mWithGeom, true );
try
{
QgsFilter* mFilter = QgsFilter::createFilterFromXml( filter.firstChild().toElement().firstChild().toElement(), layer );
while ( provider->nextFeature( feature ) && featureCounter < maxFeat )
{
if ( mFilter )
{
if ( mFilter->evaluate( feature ) )
{
sendGetFeature( request, format, &feature, featureCounter, layerCrs, fields, layerHiddenAttributes );
++featureCounter;
}
}
else
{
sendGetFeature( request, format, &feature, featureCounter, layerCrs, fields, layerHiddenAttributes );
++featureCounter;
}
}
delete mFilter;
}
catch ( QgsMapServiceException& e )
{
Q_UNUSED( e );
while ( provider->nextFeature( feature ) && featureCounter < maxFeat )
{
sendGetFeature( request, format, &feature, featureCounter, layerCrs, fields, layerHiddenAttributes );
++featureCounter;
}
}
}
else
{
if ( bboxOk )
searchRect.set( minx, miny, maxx, maxy );
provider->select( attrIndexes, searchRect, mWithGeom, true );
while ( provider->nextFeature( feature ) && featureCounter < maxFeat )
{
sendGetFeature( request, format, &feature, featureCounter, layerCrs, fields, layerHiddenAttributes );
++featureCounter;
}
}
endGetFeature( request, format );
}
else
{
return 2;
}
return 0;
}