//introduced in 1.8 QList<QgsMapLayer *> QgsMapLayerRegistry::addMapLayers( QList<QgsMapLayer *> theMapLayers, bool addToLegend, bool takeOwnership ) { QList<QgsMapLayer *> myResultList; for ( int i = 0; i < theMapLayers.size(); ++i ) { QgsMapLayer * myLayer = theMapLayers.at( i ); if ( !myLayer || !myLayer->isValid() ) { QgsDebugMsg( "cannot add invalid layers" ); continue; } //check the layer is not already registered! if ( !mMapLayers.contains( myLayer->id() ) ) { mMapLayers[myLayer->id()] = myLayer; myResultList << mMapLayers[myLayer->id()]; if ( takeOwnership ) mOwnedLayers << myLayer; emit layerWasAdded( myLayer ); } } if ( myResultList.count() > 0 ) { emit layersAdded( myResultList ); if ( addToLegend ) emit legendLayersAdded( myResultList ); } return myResultList; } // QgsMapLayerRegistry::addMapLayers
//introduced in 1.8 QList<QgsMapLayer *> QgsMapLayerRegistry::addMapLayers( QList<QgsMapLayer *> theMapLayers, bool addToLegend ) { QList<QgsMapLayer *> myResultList; for ( int i = 0; i < theMapLayers.size(); ++i ) { QgsMapLayer * myLayer = theMapLayers.at( i ); if ( !myLayer || !myLayer->isValid() ) { QgsDebugMsg( "cannot add invalid layers" ); continue; } //check the layer is not already registered! QMap<QString, QgsMapLayer*>::iterator myIterator = mMapLayers.find( myLayer->id() ); //if myIterator returns mMapLayers.end() then it //does not exist in registry and its safe to add it if ( myIterator == mMapLayers.end() ) { mMapLayers[myLayer->id()] = myLayer; myResultList << mMapLayers[myLayer->id()]; emit layerWasAdded( myLayer ); } } if ( myResultList.count() > 0 ) { emit layersAdded( myResultList ); if ( addToLegend ) emit legendLayersAdded( myResultList ); } return myResultList; } // QgsMapLayerRegistry::addMapLayers
void QgsProjectParser::layersAndStylesCapabilities( QDomElement& parentElement, QDomDocument& doc ) const { QList<QDomElement> layerElems = projectLayerElements(); QStringList nonIdentifiableLayers = identifyDisabledLayers(); if ( layerElems.size() < 1 ) { return; } QMap<QString, QgsMapLayer *> layerMap; QList<QDomElement>::const_iterator layerIt = layerElems.constBegin(); for ( ; layerIt != layerElems.constEnd(); ++layerIt ) { QgsMapLayer *layer = createLayerFromElement( *layerIt ); if ( layer ) { QgsDebugMsg( QString( "add layer %1 to map" ).arg( layer->id() ) ); layerMap.insert( layer->id(), layer ); } #if QGSMSDEBUG else { QString buf; QTextStream s( &buf ); layerIt->save( s, 0 ); QgsDebugMsg( QString( "layer %1 not found" ).arg( buf ) ); } #endif } //According to the WMS spec, there can be only one toplevel layer. //So we create an artificial one here to be in accordance with the schema QString projTitle = projectTitle(); QDomElement layerParentElem = doc.createElement( "Layer" ); layerParentElem.setAttribute( "queryable", "1" ); QDomElement layerParentNameElem = doc.createElement( "Name" ); QDomText layerParentNameText = doc.createTextNode( projTitle ); layerParentNameElem.appendChild( layerParentNameText ); layerParentElem.appendChild( layerParentNameElem ); QDomElement layerParentTitleElem = doc.createElement( "Title" ); QDomText layerParentTitleText = doc.createTextNode( projTitle ); layerParentTitleElem.appendChild( layerParentTitleText ); layerParentElem.appendChild( layerParentTitleElem ); QDomElement legendElem = mXMLDoc->documentElement().firstChildElement( "legend" ); addLayers( doc, layerParentElem, legendElem, layerMap, nonIdentifiableLayers ); parentElement.appendChild( layerParentElem ); combineExtentAndCrsOfGroupChildren( layerParentElem, doc ); }
QVariant CustomLayerOrderModel::data( const QModelIndex& index, int role ) const { QString id = mOrder.at( index.row() ); if ( role == Qt::DisplayRole ) { QgsMapLayer* layer = QgsMapLayerRegistry::instance()->mapLayer( id ); if ( layer ) return layer->name(); } if ( role == Qt::UserRole + 1 ) { QgsMapLayer* layer = QgsMapLayerRegistry::instance()->mapLayer( id ); if ( layer ) return layer->id(); } if ( role == Qt::CheckStateRole ) { QgsLayerTreeLayer* nodeLayer = mBridge->rootGroup()->findLayer( id ); if ( nodeLayer ) return nodeLayer->isVisible(); } return QVariant(); }
QStringList QgsServerProjectParser::wcsLayerNames() const { QStringList layerNameList; QMap<QString, QgsMapLayer*> layerMap; projectLayerMap( layerMap ); QgsMapLayer* currentLayer = nullptr; QStringList wcsIdList = wcsLayers(); QStringList::const_iterator wcsIdIt = wcsIdList.constBegin(); for ( ; wcsIdIt != wcsIdList.constEnd(); ++wcsIdIt ) { QMap<QString, QgsMapLayer*>::const_iterator layerMapIt = layerMap.find( *wcsIdIt ); if ( layerMapIt != layerMap.constEnd() ) { currentLayer = layerMapIt.value(); if ( currentLayer ) { layerNameList.append( mUseLayerIDs ? currentLayer->id() : currentLayer->name() ); } } } return layerNameList; }
void QgsServerProjectParser::projectLayerMap( QMap<QString, QgsMapLayer*>& layerMap ) const { layerMap.clear(); QList<QDomElement>::const_iterator layerElemIt = mProjectLayerElements.constBegin(); for ( ; layerElemIt != mProjectLayerElements.constEnd(); ++layerElemIt ) { QgsMapLayer *layer = createLayerFromElement( *layerElemIt ); if ( layer ) { layerMap.insert( layer->id(), layer ); } } }
static void _addLayerTreeNodeToUriList( QgsLayerTreeNode *node, QgsMimeDataUtils::UriList &uris ) { if ( QgsLayerTree::isGroup( node ) ) { Q_FOREACH ( QgsLayerTreeNode *child, QgsLayerTree::toGroup( node )->children() ) _addLayerTreeNodeToUriList( child, uris ); } else if ( QgsLayerTree::isLayer( node ) ) { QgsLayerTreeLayer *nodeLayer = QgsLayerTree::toLayer( node ); QgsMapLayer *layer = nodeLayer->layer(); if ( !layer ) return; QgsMimeDataUtils::Uri uri; uri.name = layer->name(); uri.uri = layer->dataProvider()->dataSourceUri(); uri.providerKey = layer->dataProvider()->name(); switch ( layer->type() ) { case QgsMapLayer::VectorLayer: { uri.layerType = QStringLiteral( "vector" ); if ( uri.providerKey == QStringLiteral( "memory" ) ) { QUrl url = QUrl::fromEncoded( uri.uri.toUtf8() ); url.addQueryItem( QStringLiteral( "pid" ), QString::number( QCoreApplication::applicationPid() ) ); url.addQueryItem( QStringLiteral( "layerid" ), layer->id() ); uri.uri = QString( url.toEncoded() ); } break; } case QgsMapLayer::RasterLayer: { uri.layerType = QStringLiteral( "raster" ); break; } case QgsMapLayer::MeshLayer: case QgsMapLayer::PluginLayer: { // plugin layers do not have a standard way of storing their URI... return; } } uris << uri; } }
QgsAddJoinDialog::QgsAddJoinDialog( QgsVectorLayer* layer, QWidget * parent, Qt::WindowFlags f ): QDialog( parent, f ), mLayer( layer ) { setupUi( this ); if ( !mLayer ) { return; } //insert possible vector layers into mJoinLayerComboBox mJoinLayerComboBox->blockSignals( true ); const QMap<QString, QgsMapLayer*>& layerList = QgsMapLayerRegistry::instance()->mapLayers(); QMap<QString, QgsMapLayer*>::const_iterator layerIt = layerList.constBegin(); for ( ; layerIt != layerList.constEnd(); ++layerIt ) { QgsMapLayer* currentLayer = layerIt.value(); if ( currentLayer->type() == QgsMapLayer::VectorLayer ) { QgsVectorLayer* currentVectorLayer = dynamic_cast<QgsVectorLayer*>( currentLayer ); if ( currentVectorLayer && currentVectorLayer != mLayer ) { if ( currentVectorLayer->dataProvider() && currentVectorLayer->dataProvider()->supportsSubsetString() ) mJoinLayerComboBox->addItem( currentLayer->name(), QVariant( currentLayer->id() ) ); } } } mJoinLayerComboBox->blockSignals( false ); on_mJoinLayerComboBox_currentIndexChanged( mJoinLayerComboBox->currentIndex() ); //insert possible target fields QgsVectorDataProvider* provider = mLayer->dataProvider(); if ( provider ) { const QgsFields& layerFields = provider->fields(); for ( int idx = 0; idx < layerFields.count(); ++idx ) { mTargetFieldComboBox->addItem( layerFields[idx].name(), idx ); } } mCacheInMemoryCheckBox->setChecked( true ); }
void QgsLayerTreeView::onCurrentChanged() { QgsMapLayer* layerCurrent = layerForIndex( currentIndex() ); QString layerCurrentID = layerCurrent ? layerCurrent->id() : QString(); if ( mCurrentLayerID == layerCurrentID ) return; // update the current index in model (the item will be underlined) QModelIndex nodeLayerIndex; if ( layerCurrent ) { QgsLayerTreeLayer* nodeLayer = layerTreeModel()->rootGroup()->findLayer( layerCurrentID ); nodeLayerIndex = layerTreeModel()->node2index( nodeLayer ); } layerTreeModel()->setCurrentIndex( nodeLayerIndex ); mCurrentLayerID = layerCurrentID; emit currentLayerChanged( layerCurrent ); }
QgsDxfExportDialog::QgsDxfExportDialog( const QList<QgsMapLayer*>& layerKeys, QWidget* parent, Qt::WindowFlags f ): QDialog( parent, f ) { setupUi( this ); connect( mFileLineEdit, SIGNAL( textChanged( const QString& ) ), this, SLOT( setOkEnabled() ) ); connect( this, SIGNAL( accepted() ), this, SLOT( saveSettings() ) ); connect( mSelectAllButton, SIGNAL( clicked() ), this, SLOT( selectAll() ) ); connect( mUnSelectAllButton, SIGNAL( clicked() ), this, SLOT( unSelectAll() ) ); QList<QgsMapLayer*>::const_iterator layerIt = layerKeys.constBegin(); for ( ; layerIt != layerKeys.constEnd(); ++layerIt ) { QgsMapLayer* layer = *layerIt; if ( layer ) { if ( layer->type() == QgsMapLayer::VectorLayer ) { QgsVectorLayer* vl = dynamic_cast<QgsVectorLayer*>( layer ); if ( !vl->hasGeometryType() ) continue; QListWidgetItem* layerItem = new QListWidgetItem( layer->name() ); layerItem->setData( Qt::UserRole, layer->id() ); layerItem->setFlags( Qt::ItemIsEnabled | Qt::ItemIsUserCheckable ); layerItem->setCheckState( Qt::Checked ); mLayersListWidget->addItem( layerItem ); } } } //last dxf symbology mode QSettings s; mSymbologyModeComboBox->setCurrentIndex( s.value( "qgis/lastDxfSymbologyMode", "2" ).toInt() ); //last symbol scale mSymbologyScaleLineEdit->setText( s.value( "qgis/lastSymbologyExportScale", "50000" ).toString() ); buttonBox->button( QDialogButtonBox::Ok )->setEnabled( false ); }
bool QgsProject::write() { clearError(); // if we have problems creating or otherwise writing to the project file, // let's find out up front before we go through all the hand-waving // necessary to create all the Dom objects if ( !imp_->file.open( QIODevice::WriteOnly | QIODevice::Text | QIODevice::Truncate ) ) { imp_->file.close(); // even though we got an error, let's make // sure it's closed anyway setError( tr( "Unable to save to file %1" ).arg( imp_->file.fileName() ) ); return false; } QFileInfo myFileInfo( imp_->file ); if ( !myFileInfo.isWritable() ) { // even though we got an error, let's make // sure it's closed anyway imp_->file.close(); setError( tr( "%1 is not writable. Please adjust permissions (if possible) and try again." ) .arg( imp_->file.fileName() ) ); return false; } QDomImplementation DomImplementation; QDomDocumentType documentType = DomImplementation.createDocumentType( "qgis", "http://mrcc.com/qgis.dtd", "SYSTEM" ); std::auto_ptr < QDomDocument > doc = std::auto_ptr < QDomDocument > ( new QDomDocument( documentType ) ); QDomElement qgisNode = doc->createElement( "qgis" ); qgisNode.setAttribute( "projectname", title() ); qgisNode.setAttribute( "version", QString( "%1" ).arg( QGis::QGIS_VERSION ) ); doc->appendChild( qgisNode ); // title QDomElement titleNode = doc->createElement( "title" ); qgisNode.appendChild( titleNode ); QDomText titleText = doc->createTextNode( title() ); // XXX why have title TWICE? titleNode.appendChild( titleText ); // let map canvas and legend write their information emit writeProject( *doc ); // within top level node save list of layers QMap<QString, QgsMapLayer*> & layers = QgsMapLayerRegistry::instance()->mapLayers(); // Iterate over layers in zOrder // Call writeXML() on each QDomElement projectLayersNode = doc->createElement( "projectlayers" ); projectLayersNode.setAttribute( "layercount", qulonglong( layers.size() ) ); QMap<QString, QgsMapLayer*>::iterator li = layers.begin(); while ( li != layers.end() ) { //QgsMapLayer *ml = QgsMapLayerRegistry::instance()->mapLayer(*li); QgsMapLayer* ml = li.value(); if ( ml ) { QString externalProjectFile = layerIsEmbedded( ml->id() ); QHash< QString, QPair< QString, bool> >::const_iterator emIt = mEmbeddedLayers.find( ml->id() ); if ( emIt == mEmbeddedLayers.constEnd() ) { ml->writeXML( projectLayersNode, *doc ); } else //layer defined in an external project file { //only save embedded layer if not managed by a legend group if ( emIt.value().second ) { QDomElement mapLayerElem = doc->createElement( "maplayer" ); mapLayerElem.setAttribute( "embedded", 1 ); mapLayerElem.setAttribute( "project", writePath( emIt.value().first ) ); mapLayerElem.setAttribute( "id", ml->id() ); projectLayersNode.appendChild( mapLayerElem ); } } } li++; } qgisNode.appendChild( projectLayersNode ); // now add the optional extra properties dump_( imp_->properties_ ); QgsDebugMsg( QString( "there are %1 property scopes" ).arg( static_cast<int>( imp_->properties_.count() ) ) ); if ( !imp_->properties_.isEmpty() ) // only worry about properties if we // actually have any properties { imp_->properties_.writeXML( "properties", qgisNode, *doc ); } // now wrap it up and ship it to the project file doc->normalize(); // XXX I'm not entirely sure what this does //QString xml = doc->toString(4); // write to string with indentation of four characters // (yes, four is arbitrary) // const char * xmlString = xml; // debugger probe point // qDebug( "project file output:\n\n" + xml ); QTextStream projectFileStream( &imp_->file ); //projectFileStream << xml << endl; doc->save( projectFileStream, 4 ); // save as utf-8 imp_->file.close(); // check if the text stream had no error - if it does // the user will get a message so they can try to resolve the // situation e.g. by saving project to a volume with more space // if ( projectFileStream.pos() == -1 || imp_->file.error() != QFile::NoError ) { setError( tr( "Unable to save to file %1. Your project " "may be corrupted on disk. Try clearing some space on the volume and " "check file permissions before pressing save again." ) .arg( imp_->file.fileName() ) ); return false; } dirty( false ); // reset to pristine state emit projectSaved(); return true; } // QgsProject::write
QDomElement getFeatureTypeListElement( QDomDocument &doc, QgsServerInterface *serverIface, const QgsProject *project ) { QgsAccessControl *accessControl = serverIface->accessControls(); //wfs:FeatureTypeList element QDomElement featureTypeListElement = doc.createElement( QStringLiteral( "FeatureTypeList" )/*wfs:FeatureTypeList*/ ); //wfs:Operations element QDomElement operationsElement = doc.createElement( QStringLiteral( "Operations" )/*wfs:Operations*/ ); featureTypeListElement.appendChild( operationsElement ); //wfs:Query element QDomElement queryElement = doc.createElement( QStringLiteral( "Query" )/*wfs:Query*/ ); operationsElement.appendChild( queryElement ); QStringList wfsLayerIds = QgsServerProjectUtils::wfsLayerIds( *project ); QStringList wfstUpdateLayersId = QgsServerProjectUtils::wfstUpdateLayerIds( *project ); QStringList wfstInsertLayersId = QgsServerProjectUtils::wfstInsertLayerIds( *project ); QStringList wfstDeleteLayersId = QgsServerProjectUtils::wfstDeleteLayerIds( *project ); for ( int i = 0; i < wfsLayerIds.size(); ++i ) { QgsMapLayer *layer = project->mapLayer( wfsLayerIds.at( i ) ); if ( layer->type() != QgsMapLayer::LayerType::VectorLayer ) { continue; } if ( accessControl && !accessControl->layerReadPermission( layer ) ) { continue; } QDomElement layerElem = doc.createElement( QStringLiteral( "FeatureType" ) ); //create Name QDomElement nameElem = doc.createElement( QStringLiteral( "Name" ) ); QString typeName = layer->name(); if ( !layer->shortName().isEmpty() ) typeName = layer->shortName(); typeName = typeName.replace( QLatin1String( " " ), QLatin1String( "_" ) ); QDomText nameText = doc.createTextNode( typeName ); nameElem.appendChild( nameText ); layerElem.appendChild( nameElem ); //create Title QDomElement titleElem = doc.createElement( QStringLiteral( "Title" ) ); QString title = layer->title(); if ( title.isEmpty() ) { title = layer->name(); } QDomText titleText = doc.createTextNode( title ); titleElem.appendChild( titleText ); layerElem.appendChild( titleElem ); //create Abstract QString abstract = layer->abstract(); if ( !abstract.isEmpty() ) { QDomElement abstractElem = doc.createElement( QStringLiteral( "Abstract" ) ); QDomText abstractText = doc.createTextNode( abstract ); abstractElem.appendChild( abstractText ); layerElem.appendChild( abstractElem ); } //create keywords QString keywords = layer->keywordList(); if ( !keywords.isEmpty() ) { QDomElement keywordsElem = doc.createElement( QStringLiteral( "Keywords" ) ); QDomText keywordsText = doc.createTextNode( keywords ); keywordsElem.appendChild( keywordsText ); layerElem.appendChild( keywordsElem ); } //create SRS QDomElement srsElem = doc.createElement( QStringLiteral( "SRS" ) ); QDomText srsText = doc.createTextNode( layer->crs().authid() ); srsElem.appendChild( srsText ); layerElem.appendChild( srsElem ); //create LatLongBoundingBox QgsRectangle layerExtent = layer->extent(); QDomElement bBoxElement = doc.createElement( QStringLiteral( "LatLongBoundingBox" ) ); bBoxElement.setAttribute( QStringLiteral( "minx" ), QString::number( layerExtent.xMinimum() ) ); bBoxElement.setAttribute( QStringLiteral( "miny" ), QString::number( layerExtent.yMinimum() ) ); bBoxElement.setAttribute( QStringLiteral( "maxx" ), QString::number( layerExtent.xMaximum() ) ); bBoxElement.setAttribute( QStringLiteral( "maxy" ), QString::number( layerExtent.yMaximum() ) ); layerElem.appendChild( bBoxElement ); // layer metadata URL QString metadataUrl = layer->metadataUrl(); if ( !metadataUrl.isEmpty() ) { QDomElement metaUrlElem = doc.createElement( QStringLiteral( "MetadataURL" ) ); QString metadataUrlType = layer->metadataUrlType(); metaUrlElem.setAttribute( QStringLiteral( "type" ), metadataUrlType ); QString metadataUrlFormat = layer->metadataUrlFormat(); if ( metadataUrlFormat == QLatin1String( "text/xml" ) ) { metaUrlElem.setAttribute( QStringLiteral( "format" ), QStringLiteral( "XML" ) ); } else { metaUrlElem.setAttribute( QStringLiteral( "format" ), QStringLiteral( "TXT" ) ); } QDomText metaUrlText = doc.createTextNode( metadataUrl ); metaUrlElem.appendChild( metaUrlText ); layerElem.appendChild( metaUrlElem ); } //wfs:Operations element QDomElement operationsElement = doc.createElement( QStringLiteral( "Operations" )/*wfs:Operations*/ ); //wfs:Query element QDomElement queryElement = doc.createElement( QStringLiteral( "Query" )/*wfs:Query*/ ); operationsElement.appendChild( queryElement ); if ( wfstUpdateLayersId.contains( layer->id() ) || wfstInsertLayersId.contains( layer->id() ) || wfstDeleteLayersId.contains( layer->id() ) ) { QgsVectorLayer *vlayer = qobject_cast<QgsVectorLayer *>( layer ); QgsVectorDataProvider *provider = vlayer->dataProvider(); if ( ( provider->capabilities() & QgsVectorDataProvider::AddFeatures ) && wfstInsertLayersId.contains( layer->id() ) ) { //wfs:Insert element QDomElement insertElement = doc.createElement( QStringLiteral( "Insert" )/*wfs:Insert*/ ); operationsElement.appendChild( insertElement ); } if ( ( provider->capabilities() & QgsVectorDataProvider::ChangeAttributeValues ) && ( provider->capabilities() & QgsVectorDataProvider::ChangeGeometries ) && wfstUpdateLayersId.contains( layer->id() ) ) { //wfs:Update element QDomElement updateElement = doc.createElement( QStringLiteral( "Update" )/*wfs:Update*/ ); operationsElement.appendChild( updateElement ); } if ( ( provider->capabilities() & QgsVectorDataProvider::DeleteFeatures ) && wfstDeleteLayersId.contains( layer->id() ) ) { //wfs:Delete element QDomElement deleteElement = doc.createElement( QStringLiteral( "Delete" )/*wfs:Delete*/ ); operationsElement.appendChild( deleteElement ); } } layerElem.appendChild( operationsElement ); featureTypeListElement.appendChild( layerElem ); } return featureTypeListElement; }
QList<QgsMapToolIdentify::IdentifyResult> QgsMapToolIdentify::identify( int x, int y, IdentifyMode mode, QList<QgsMapLayer*> layerList, LayerType layerType ) { QList<IdentifyResult> results; mLastPoint = mCanvas->getCoordinateTransform()->toMapCoordinates( x, y ); mLastExtent = mCanvas->extent(); mLastMapUnitsPerPixel = mCanvas->mapUnitsPerPixel(); if ( mode == DefaultQgsSetting ) { QSettings settings; mode = static_cast<IdentifyMode>( settings.value( "/Map/identifyMode", 0 ).toInt() ); } if ( mode == LayerSelection ) { // fill map of layer / identify results mLayerIdResults.clear(); QList<IdentifyResult> idResult = identify( x, y, TopDownAll ); QList<IdentifyResult>::const_iterator it = idResult.constBegin(); for ( ; it != idResult.constEnd(); ++it ) { QgsMapLayer *layer = it->mLayer; if ( mLayerIdResults.contains( layer ) ) { mLayerIdResults[layer].append( *it ); } else { mLayerIdResults.insert( layer, QList<IdentifyResult>() << *it ); } } //fill selection menu with entries from mmLayerIdResults QMenu layerSelectionMenu; QMap< QgsMapLayer*, QList<IdentifyResult> >::const_iterator resultIt = mLayerIdResults.constBegin(); for ( ; resultIt != mLayerIdResults.constEnd(); ++resultIt ) { QAction* action = new QAction( QString( "%1 (%2)" ).arg( resultIt.key()->name() ).arg( resultIt.value().size() ), 0 ); action->setData( resultIt.key()->id() ); //add point/line/polygon icon QgsVectorLayer* vl = qobject_cast<QgsVectorLayer*>( resultIt.key() ); if ( vl ) { switch ( vl->geometryType() ) { case QGis::Point: action->setIcon( QgsApplication::getThemeIcon( "/mIconPointLayer.png" ) ); break; case QGis::Line: action->setIcon( QgsApplication::getThemeIcon( "/mIconLineLayer.png" ) ); break; case QGis::Polygon: action->setIcon( QgsApplication::getThemeIcon( "/mIconPolygonLayer.png" ) ); break; default: break; } } else if ( resultIt.key()->type() == QgsMapLayer::RasterLayer ) { action->setIcon( QgsApplication::getThemeIcon( "/mIconRaster.png" ) ); } connect( action, SIGNAL( hovered() ), this, SLOT( handleMenuHover() ) ); layerSelectionMenu.addAction( action ); } if ( mLayerIdResults.size() > 1 ) { QAction *action = new QAction( tr( "All (%1)" ).arg( idResult.size() ), 0 ); connect( action, SIGNAL( hovered() ), this, SLOT( handleMenuHover() ) ); layerSelectionMenu.addAction( action ); } // exec layer selection menu QPoint globalPos = mCanvas->mapToGlobal( QPoint( x + 5, y + 5 ) ); QAction* selectedAction = layerSelectionMenu.exec( globalPos ); if ( selectedAction ) { if ( selectedAction->data().toString().isEmpty() ) { results = idResult; } else { QgsMapLayer* selectedLayer = QgsMapLayerRegistry::instance()->mapLayer( selectedAction->data().toString() ); QMap< QgsMapLayer*, QList<IdentifyResult> >::const_iterator sIt = mLayerIdResults.find( selectedLayer ); if ( sIt != mLayerIdResults.constEnd() ) { results = sIt.value(); } } } deleteRubberBands(); } else if ( mode == ActiveLayer && layerList.isEmpty() ) { QgsMapLayer *layer = mCanvas->currentLayer(); if ( !layer ) { emit identifyMessage( tr( "No active layer. To identify features, you must choose an active layer." ) ); return results; } QApplication::setOverrideCursor( Qt::WaitCursor ); identifyLayer( &results, layer, mLastPoint, mLastExtent, mLastMapUnitsPerPixel, layerType ); } else { QApplication::setOverrideCursor( Qt::WaitCursor ); QStringList noIdentifyLayerIdList = QgsProject::instance()->readListEntry( "Identify", "/disabledLayers" ); int layerCount; if ( layerList.isEmpty() ) layerCount = mCanvas->layerCount(); else layerCount = layerList.count(); for ( int i = 0; i < layerCount; i++ ) { QgsMapLayer *layer ; if ( layerList.isEmpty() ) layer = mCanvas->layer( i ); else layer = layerList.value( i ); emit identifyProgress( i, mCanvas->layerCount() ); emit identifyMessage( tr( "Identifying on %1..." ).arg( layer->name() ) ); if ( noIdentifyLayerIdList.contains( layer->id() ) ) continue; if ( identifyLayer( &results, layer, mLastPoint, mLastExtent, mLastMapUnitsPerPixel, layerType ) ) { if ( mode == TopDownStopAtFirst ) break; } } emit identifyProgress( mCanvas->layerCount(), mCanvas->layerCount() ); emit identifyMessage( tr( "Identifying done." ) ); } QApplication::restoreOverrideCursor(); return results; }
QgsComposition* QgsWMSConfigParser::createPrintComposition( const QString& composerTemplate, QgsMapRenderer* mapRenderer, const QMap< QString, QString >& parameterMap ) const { QList<QgsComposerMap*> composerMaps; QList<QgsComposerLegend*> composerLegends; QList<QgsComposerLabel*> composerLabels; QList<const QgsComposerHtml*> composerHtmls; QgsComposition* c = initComposition( composerTemplate, mapRenderer, composerMaps, composerLegends, composerLabels, composerHtmls ); if ( !c ) { return 0; } QString dpi = parameterMap.value( "DPI" ); if ( !dpi.isEmpty() ) { c->setPrintResolution( dpi.toInt() ); } //replace composer map parameters Q_FOREACH ( QgsComposerMap* currentMap, composerMaps ) { if ( !currentMap ) { continue; } QString mapId = "MAP" + QString::number( currentMap->id() ); QString extent = parameterMap.value( mapId + ":EXTENT" ); if ( extent.isEmpty() ) //map extent is mandatory { //remove map from composition if not referenced by the request c->removeItem( currentMap ); delete currentMap; continue; } QStringList coordList = extent.split( "," ); if ( coordList.size() < 4 ) { c->removeItem( currentMap ); delete currentMap; continue; //need at least four coordinates } bool xMinOk, yMinOk, xMaxOk, yMaxOk; double xmin = coordList.at( 0 ).toDouble( &xMinOk ); double ymin = coordList.at( 1 ).toDouble( &yMinOk ); double xmax = coordList.at( 2 ).toDouble( &xMaxOk ); double ymax = coordList.at( 3 ).toDouble( &yMaxOk ); if ( !xMinOk || !yMinOk || !xMaxOk || !yMaxOk ) { c->removeItem( currentMap ); delete currentMap; continue; } QgsRectangle r( xmin, ymin, xmax, ymax ); //Change x- and y- of extent for WMS 1.3.0 if axis inverted QString version = parameterMap.value( "VERSION" ); if ( version == "1.3.0" && mapRenderer && mapRenderer->destinationCrs().axisInverted() ) { r.invert(); } currentMap->setNewExtent( r ); //scale QString scaleString = parameterMap.value( mapId + ":SCALE" ); if ( !scaleString.isEmpty() ) { bool scaleOk; double scale = scaleString.toDouble( &scaleOk ); if ( scaleOk ) { currentMap->setNewScale( scale ); } } //rotation QString rotationString = parameterMap.value( mapId + ":ROTATION" ); if ( !rotationString.isEmpty() ) { bool rotationOk; double rotation = rotationString.toDouble( &rotationOk ); if ( rotationOk ) { currentMap->setMapRotation( rotation ); } } //layers / styles QString layers = parameterMap.value( mapId + ":LAYERS" ); QString styles = parameterMap.value( mapId + ":STYLES" ); if ( !layers.isEmpty() ) { QStringList layerSet; QStringList wmsLayerList = layers.split( ",", QString::SkipEmptyParts ); QStringList wmsStyleList; if ( !styles.isEmpty() ) { wmsStyleList = styles.split( ",", QString::SkipEmptyParts ); } for ( int i = 0; i < wmsLayerList.size(); ++i ) { QString wmsLayer = wmsLayerList.at( i ); QString styleName; if ( wmsStyleList.size() > i ) { styleName = wmsStyleList.at( i ); } bool allowCaching = true; if ( wmsLayerList.count( wmsLayer ) > 1 ) { allowCaching = false; } QList<QgsMapLayer*> layerList = mapLayerFromStyle( wmsLayer, styleName, allowCaching ); int listIndex; for ( listIndex = layerList.size() - 1; listIndex >= 0; listIndex-- ) { QgsMapLayer* layer = layerList.at( listIndex ); if ( layer ) { layerSet.push_back( layer->id() ); } } } currentMap->setLayerSet( layerSet ); currentMap->setKeepLayerSet( true ); } //grid space x / y currentMap->grid()->setIntervalX( parameterMap.value( mapId + ":GRID_INTERVAL_X" ).toDouble() ); currentMap->grid()->setIntervalY( parameterMap.value( mapId + ":GRID_INTERVAL_Y" ).toDouble() ); } //update legend // if it has an auto-update model Q_FOREACH ( QgsComposerLegend* currentLegend, composerLegends ) { if ( !currentLegend ) { continue; } if ( currentLegend->autoUpdateModel() || currentLegend->legendFilterByMapEnabled() ) { // the legend has an auto-update model or // has to be filter by map // we will update it with map's layers const QgsComposerMap* map = currentLegend->composerMap(); if ( !map ) { continue; } // get model and layer tree root of the legend QgsLegendModelV2* model = currentLegend->modelV2(); QgsLayerTreeGroup* root = model->rootGroup(); // get layerIds find in the layer tree root QStringList layerIds = root->findLayerIds(); // get map layerIds QStringList layerSet = map->layerSet(); // get map scale double scale = map->scale(); // Q_FOREACH layer find in the layer tree // remove it if the layer id is not in map layerIds Q_FOREACH ( const QString& layerId, layerIds ) { QgsLayerTreeLayer* nodeLayer = root->findLayer( layerId ); if ( !nodeLayer ) { continue; } if ( !layerSet.contains( layerId ) ) { qobject_cast<QgsLayerTreeGroup*>( nodeLayer->parent() )->removeChildNode( nodeLayer ); } else { QgsMapLayer* layer = nodeLayer->layer(); if ( layer->hasScaleBasedVisibility() ) { if ( layer->minimumScale() > scale ) qobject_cast<QgsLayerTreeGroup*>( nodeLayer->parent() )->removeChildNode( nodeLayer ); else if ( layer->maximumScale() < scale ) qobject_cast<QgsLayerTreeGroup*>( nodeLayer->parent() )->removeChildNode( nodeLayer ); } } } root->removeChildrenGroupWithoutLayers(); } }
QgsProjectProperties::QgsProjectProperties( QgsMapCanvas* mapCanvas, QWidget *parent, Qt::WFlags fl ) : QDialog( parent, fl ) , mMapCanvas( mapCanvas ) { setupUi( this ); connect( buttonBox, SIGNAL( accepted() ), this, SLOT( accept() ) ); connect( buttonBox, SIGNAL( rejected() ), this, SLOT( reject() ) ); connect( buttonBox->button( QDialogButtonBox::Apply ), SIGNAL( clicked() ), this, SLOT( apply() ) ); connect( this, SIGNAL( accepted() ), this, SLOT( apply() ) ); connect( projectionSelector, SIGNAL( sridSelected( QString ) ), this, SLOT( setMapUnitsToCurrentProjection() ) ); /////////////////////////////////////////////////////////// // Properties stored in map canvas's QgsMapRenderer // these ones are propagated to QgsProject by a signal QgsMapRenderer* myRenderer = mMapCanvas->mapRenderer(); QGis::UnitType myUnit = myRenderer->mapUnits(); setMapUnits( myUnit ); // we need to initialize it, since the on_cbxProjectionEnabled_stateChanged() // callback triggered by setChecked() might use it. mProjectSrsId = myRenderer->destinationCrs().srsid(); //see if the user wants on the fly projection enabled bool myProjectionEnabled = myRenderer->hasCrsTransformEnabled(); cbxProjectionEnabled->setChecked( myProjectionEnabled ); QgsDebugMsg( "Read project CRSID: " + QString::number( mProjectSrsId ) ); projectionSelector->setSelectedCrsId( mProjectSrsId ); projectionSelector->setEnabled( myProjectionEnabled ); /////////////////////////////////////////////////////////// // Properties stored in QgsProject title( QgsProject::instance()->title() ); // get the manner in which the number of decimal places in the mouse // position display is set (manual or automatic) bool automaticPrecision = QgsProject::instance()->readBoolEntry( "PositionPrecision", "/Automatic" ); if ( automaticPrecision ) { radAutomatic->setChecked( true ); spinBoxDP->setDisabled( true ); labelDP->setDisabled( true ); } else { radManual->setChecked( true ); } cbxAbsolutePath->setCurrentIndex( QgsProject::instance()->readBoolEntry( "Paths", "/Absolute", true ) ? 0 : 1 ); int dp = QgsProject::instance()->readNumEntry( "PositionPrecision", "/DecimalPlaces" ); spinBoxDP->setValue( dp ); QString format = QgsProject::instance()->readEntry( "PositionPrecision", "/DegreeFormat", "D" ); if ( format == "DM" ) radDM->setChecked( true ); else if ( format == "DMS" ) radDMS->setChecked( true ); else radD->setChecked( true ); //get the color selections and set the button color accordingly int myRedInt = QgsProject::instance()->readNumEntry( "Gui", "/SelectionColorRedPart", 255 ); int myGreenInt = QgsProject::instance()->readNumEntry( "Gui", "/SelectionColorGreenPart", 255 ); int myBlueInt = QgsProject::instance()->readNumEntry( "Gui", "/SelectionColorBluePart", 0 ); int myAlphaInt = QgsProject::instance()->readNumEntry( "Gui", "/SelectionColorAlphaPart", 255 ); QColor myColor = QColor( myRedInt, myGreenInt, myBlueInt, myAlphaInt ); pbnSelectionColor->setColor( myColor ); //get the color for map canvas background and set button color accordingly (default white) myRedInt = QgsProject::instance()->readNumEntry( "Gui", "/CanvasColorRedPart", 255 ); myGreenInt = QgsProject::instance()->readNumEntry( "Gui", "/CanvasColorGreenPart", 255 ); myBlueInt = QgsProject::instance()->readNumEntry( "Gui", "/CanvasColorBluePart", 255 ); myColor = QColor( myRedInt, myGreenInt, myBlueInt ); pbnCanvasColor->setColor( myColor ); //get project scales QStringList myScales = QgsProject::instance()->readListEntry( "Scales", "/ScalesList" ); if ( !myScales.isEmpty() ) { QStringList::const_iterator scaleIt = myScales.constBegin(); for ( ; scaleIt != myScales.constEnd(); ++scaleIt ) { QListWidgetItem* newItem = new QListWidgetItem( lstScales ); newItem->setText( *scaleIt ); newItem->setFlags( Qt::ItemIsEditable | Qt::ItemIsEnabled | Qt::ItemIsSelectable ); lstScales->addItem( newItem ); } } grpProjectScales->setChecked( QgsProject::instance()->readBoolEntry( "Scales", "/useProjectScales" ) ); QgsMapLayer* currentLayer = 0; QStringList noIdentifyLayerIdList = QgsProject::instance()->readListEntry( "Identify", "/disabledLayers" ); const QMap<QString, QgsMapLayer*> &mapLayers = QgsMapLayerRegistry::instance()->mapLayers(); if ( mMapCanvas->currentLayer() ) { mLayerSrsId = mMapCanvas->currentLayer()->crs().srsid(); } else if ( mapLayers.size() > 0 ) { mLayerSrsId = mapLayers.begin().value()->crs().srsid(); } else { mLayerSrsId = mProjectSrsId; } twIdentifyLayers->setColumnCount( 3 ); twIdentifyLayers->horizontalHeader()->setVisible( true ); twIdentifyLayers->setHorizontalHeaderItem( 0, new QTableWidgetItem( tr( "Layer" ) ) ); twIdentifyLayers->setHorizontalHeaderItem( 1, new QTableWidgetItem( tr( "Type" ) ) ); twIdentifyLayers->setHorizontalHeaderItem( 2, new QTableWidgetItem( tr( "Identifiable" ) ) ); twIdentifyLayers->setRowCount( mapLayers.size() ); twIdentifyLayers->verticalHeader()->setResizeMode( QHeaderView::ResizeToContents ); int i = 0; for ( QMap<QString, QgsMapLayer*>::const_iterator it = mapLayers.constBegin(); it != mapLayers.constEnd(); it++, i++ ) { currentLayer = it.value(); QTableWidgetItem *twi = new QTableWidgetItem( QString::number( i ) ); twIdentifyLayers->setVerticalHeaderItem( i, twi ); twi = new QTableWidgetItem( currentLayer->name() ); twi->setData( Qt::UserRole, it.key() ); twi->setFlags( twi->flags() & ~Qt::ItemIsEditable ); twIdentifyLayers->setItem( i, 0, twi ); QString type; if ( currentLayer->type() == QgsMapLayer::VectorLayer ) { type = tr( "Vector" ); } else if ( currentLayer->type() == QgsMapLayer::RasterLayer ) { QgsRasterLayer *rl = qobject_cast<QgsRasterLayer *>( currentLayer ); if ( rl && rl->providerType() == "wms" ) { type = tr( "WMS" ); } else { type = tr( "Raster" ); } } twi = new QTableWidgetItem( type ); twi->setFlags( twi->flags() & ~Qt::ItemIsEditable ); twIdentifyLayers->setItem( i, 1, twi ); QCheckBox *cb = new QCheckBox(); cb->setChecked( !noIdentifyLayerIdList.contains( currentLayer->id() ) ); twIdentifyLayers->setCellWidget( i, 2, cb ); } grpOWSServiceCapabilities->setChecked( QgsProject::instance()->readBoolEntry( "WMSServiceCapabilities", "/", false ) ); mWMSTitle->setText( QgsProject::instance()->readEntry( "WMSServiceTitle", "/" ) ); mWMSContactOrganization->setText( QgsProject::instance()->readEntry( "WMSContactOrganization", "/", "" ) ); mWMSContactPerson->setText( QgsProject::instance()->readEntry( "WMSContactPerson", "/", "" ) ); mWMSContactMail->setText( QgsProject::instance()->readEntry( "WMSContactMail", "/", "" ) ); mWMSContactPhone->setText( QgsProject::instance()->readEntry( "WMSContactPhone", "/", "" ) ); mWMSAbstract->setPlainText( QgsProject::instance()->readEntry( "WMSServiceAbstract", "/", "" ) ); mWMSOnlineResourceLineEdit->setText( QgsProject::instance()->readEntry( "WMSOnlineResource", "/", "" ) ); mWMSUrlLineEdit->setText( QgsProject::instance()->readEntry( "WMSUrl", "/", "" ) ); bool ok; QStringList values; mWMSExtMinX->setValidator( new QDoubleValidator( mWMSExtMinX ) ); mWMSExtMinY->setValidator( new QDoubleValidator( mWMSExtMinY ) ); mWMSExtMaxX->setValidator( new QDoubleValidator( mWMSExtMaxX ) ); mWMSExtMaxY->setValidator( new QDoubleValidator( mWMSExtMaxY ) ); values = QgsProject::instance()->readListEntry( "WMSExtent", "/", &ok ); grpWMSExt->setChecked( ok && values.size() == 4 ); if ( grpWMSExt->isChecked() ) { mWMSExtMinX->setText( values[0] ); mWMSExtMinY->setText( values[1] ); mWMSExtMaxX->setText( values[2] ); mWMSExtMaxY->setText( values[3] ); } values = QgsProject::instance()->readListEntry( "WMSCrsList", "/", &ok ); grpWMSList->setChecked( ok && values.size() > 0 ); if ( grpWMSList->isChecked() ) { mWMSList->addItems( values ); } else { values = QgsProject::instance()->readListEntry( "WMSEpsgList", "/", &ok ); grpWMSList->setChecked( ok && values.size() > 0 ); if ( grpWMSList->isChecked() ) { QStringList list; foreach ( QString value, values ) { list << QString( "EPSG:%1" ).arg( value ); } mWMSList->addItems( list ); }
LayerRenderJobs QgsMapRendererJob::prepareJobs( QPainter* painter, QgsPalLabeling* labelingEngine ) { LayerRenderJobs layerJobs; // render all layers in the stack, starting at the base QListIterator<QString> li( mSettings.layers() ); li.toBack(); if ( mCache ) { bool cacheValid = mCache->init( mSettings.visibleExtent(), mSettings.scale() ); QgsDebugMsg( QString( "CACHE VALID: %1" ).arg( cacheValid ) ); Q_UNUSED( cacheValid ); } mGeometryCaches.clear(); while ( li.hasPrevious() ) { QString layerId = li.previous(); QgsDebugMsg( "Rendering at layer item " + layerId ); QgsMapLayer *ml = QgsMapLayerRegistry::instance()->mapLayer( layerId ); if ( !ml ) { mErrors.append( Error( layerId, "Layer not found in registry." ) ); continue; } QgsDebugMsg( QString( "layer %1: minscale:%2 maxscale:%3 scaledepvis:%4 extent:%5 blendmode:%6" ) .arg( ml->name() ) .arg( ml->minimumScale() ) .arg( ml->maximumScale() ) .arg( ml->hasScaleBasedVisibility() ) .arg( ml->extent().toString() ) .arg( ml->blendMode() ) ); if ( ml->hasScaleBasedVisibility() && ( mSettings.scale() < ml->minimumScale() || mSettings.scale() > ml->maximumScale() ) ) //|| mOverview ) { QgsDebugMsg( "Layer not rendered because it is not within the defined visibility scale range" ); continue; } QgsRectangle r1 = mSettings.visibleExtent(), r2; const QgsCoordinateTransform* ct = 0; if ( mSettings.hasCrsTransformEnabled() ) { ct = mSettings.layerTransfrom( ml ); if ( ct ) { reprojectToLayerExtent( ct, ml->crs().geographicFlag(), r1, r2 ); } QgsDebugMsg( "extent: " + r1.toString() ); if ( !r1.isFinite() || !r2.isFinite() ) { mErrors.append( Error( layerId, "There was a problem transforming layer's' extent. Layer skipped." ) ); continue; } } // Force render of layers that are being edited // or if there's a labeling engine that needs the layer to register features if ( mCache && ml->type() == QgsMapLayer::VectorLayer ) { QgsVectorLayer* vl = qobject_cast<QgsVectorLayer *>( ml ); if ( vl->isEditable() || ( labelingEngine && labelingEngine->willUseLayer( vl ) ) ) mCache->clearCacheImage( ml->id() ); } layerJobs.append( LayerRenderJob() ); LayerRenderJob& job = layerJobs.last(); job.cached = false; job.img = 0; job.blendMode = ml->blendMode(); job.layerId = ml->id(); job.context = QgsRenderContext::fromMapSettings( mSettings ); job.context.setPainter( painter ); job.context.setLabelingEngine( labelingEngine ); job.context.setCoordinateTransform( ct ); job.context.setExtent( r1 ); // if we can use the cache, let's do it and avoid rendering! if ( mCache && !mCache->cacheImage( ml->id() ).isNull() ) { job.cached = true; job.img = new QImage( mCache->cacheImage( ml->id() ) ); job.renderer = 0; job.context.setPainter( 0 ); continue; } // If we are drawing with an alternative blending mode then we need to render to a separate image // before compositing this on the map. This effectively flattens the layer and prevents // blending occuring between objects on the layer if ( mCache || !painter || needTemporaryImage( ml ) ) { // Flattened image for drawing when a blending mode is set QImage * mypFlattenedImage = 0; mypFlattenedImage = new QImage( mSettings.outputSize().width(), mSettings.outputSize().height(), mSettings.outputImageFormat() ); if ( mypFlattenedImage->isNull() ) { mErrors.append( Error( layerId, "Insufficient memory for image " + QString::number( mSettings.outputSize().width() ) + "x" + QString::number( mSettings.outputSize().height() ) ) ); delete mypFlattenedImage; layerJobs.removeLast(); continue; } mypFlattenedImage->fill( 0 ); job.img = mypFlattenedImage; QPainter* mypPainter = new QPainter( job.img ); mypPainter->setRenderHint( QPainter::Antialiasing, mSettings.testFlag( QgsMapSettings::Antialiasing ) ); job.context.setPainter( mypPainter ); } job.renderer = ml->createMapRenderer( job.context ); if ( mRequestedGeomCacheForLayers.contains( ml->id() ) ) { if ( QgsVectorLayerRenderer* vlr = dynamic_cast<QgsVectorLayerRenderer*>( job.renderer ) ) { vlr->setGeometryCachePointer( &mGeometryCaches[ ml->id()] ); } } } // while (li.hasPrevious()) return layerJobs; }
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; }
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 QgsMapRendererCache::layerRequestedRepaint() { QgsMapLayer* layer = qobject_cast<QgsMapLayer*>( sender() ); if ( layer ) clearCacheImage( layer->id() ); }
void QgsWfsProjectParser::featureTypeList( QDomElement& parentElement, QDomDocument& doc ) const { const QList<QDomElement>& projectLayerElements = mProjectParser->projectLayerElements(); if ( projectLayerElements.size() < 1 ) { return; } QStringList wfsLayersId = mProjectParser->wfsLayers(); QSet<QString> wfstUpdateLayersId = wfstUpdateLayers(); QSet<QString> wfstInsertLayersId = wfstInsertLayers(); QSet<QString> wfstDeleteLayersId = wfstDeleteLayers(); QMap<QString, QgsMapLayer *> layerMap; Q_FOREACH ( const QDomElement &elem, projectLayerElements ) { QString type = elem.attribute( "type" ); if ( type == "vector" ) { QString layerId = mProjectParser->layerId( elem ); if ( !wfsLayersId.contains( layerId ) ) { continue; } QgsMapLayer *layer = mProjectParser->createLayerFromElement( elem ); if ( !layer ) { continue; } #ifdef HAVE_SERVER_PYTHON_PLUGINS if ( !mAccessControl->layerReadPermission( layer ) ) { continue; } #endif QgsDebugMsg( QString( "add layer %1 to map" ).arg( layer->id() ) ); layerMap.insert( layer->id(), layer ); QDomElement layerElem = doc.createElement( "FeatureType" ); QDomElement nameElem = doc.createElement( "Name" ); //We use the layer name even though it might not be unique. //Because the id sometimes contains user/pw information and the name is more descriptive QString typeName = layer->name(); if ( !layer->shortName().isEmpty() ) typeName = layer->shortName(); typeName = typeName.replace( " ", "_" ); QDomText nameText = doc.createTextNode( typeName ); nameElem.appendChild( nameText ); layerElem.appendChild( nameElem ); QDomElement titleElem = doc.createElement( "Title" ); QString titleName = layer->title(); if ( titleName.isEmpty() ) { titleName = layer->name(); } QDomText titleText = doc.createTextNode( titleName ); titleElem.appendChild( titleText ); layerElem.appendChild( titleElem ); QDomElement abstractElem = doc.createElement( "Abstract" ); QString abstractName = layer->abstract(); if ( abstractName.isEmpty() ) { abstractName = ""; } QDomText abstractText = doc.createTextNode( abstractName ); abstractElem.appendChild( abstractText ); layerElem.appendChild( abstractElem ); //keyword list if ( !layer->keywordList().isEmpty() ) { QDomElement keywordsElem = doc.createElement( "Keywords" ); QDomText keywordsText = doc.createTextNode( layer->keywordList() ); keywordsElem.appendChild( keywordsText ); layerElem.appendChild( keywordsElem ); } //appendExGeographicBoundingBox( layerElem, doc, layer->extent(), layer->crs() ); QDomElement srsElem = doc.createElement( "SRS" ); QDomText srsText = doc.createTextNode( layer->crs().authid() ); srsElem.appendChild( srsText ); layerElem.appendChild( srsElem ); //wfs:Operations element QDomElement operationsElement = doc.createElement( "Operations"/*wfs:Operations*/ ); //wfs:Query element QDomElement queryElement = doc.createElement( "Query"/*wfs:Query*/ ); operationsElement.appendChild( queryElement ); QgsVectorLayer* vlayer = qobject_cast<QgsVectorLayer*>( layer ); QgsVectorDataProvider* provider = vlayer->dataProvider(); if (( provider->capabilities() & QgsVectorDataProvider::AddFeatures ) && wfstInsertLayersId.contains( layer->id() ) ) { //wfs:Insert element QDomElement insertElement = doc.createElement( "Insert"/*wfs:Insert*/ ); operationsElement.appendChild( insertElement ); } if (( provider->capabilities() & QgsVectorDataProvider::ChangeAttributeValues ) && ( provider->capabilities() & QgsVectorDataProvider::ChangeGeometries ) && wfstUpdateLayersId.contains( layer->id() ) ) { //wfs:Update element QDomElement updateElement = doc.createElement( "Update"/*wfs:Update*/ ); operationsElement.appendChild( updateElement ); } if (( provider->capabilities() & QgsVectorDataProvider::DeleteFeatures ) && wfstDeleteLayersId.contains( layer->id() ) ) { //wfs:Delete element QDomElement deleteElement = doc.createElement( "Delete"/*wfs:Delete*/ ); operationsElement.appendChild( deleteElement ); } layerElem.appendChild( operationsElement ); QgsRectangle layerExtent = layer->extent(); QDomElement bBoxElement = doc.createElement( "LatLongBoundingBox" ); bBoxElement.setAttribute( "minx", QString::number( layerExtent.xMinimum() ) ); bBoxElement.setAttribute( "miny", QString::number( layerExtent.yMinimum() ) ); bBoxElement.setAttribute( "maxx", QString::number( layerExtent.xMaximum() ) ); bBoxElement.setAttribute( "maxy", QString::number( layerExtent.yMaximum() ) ); layerElem.appendChild( bBoxElement ); // layer metadata URL QString metadataUrl = layer->metadataUrl(); if ( !metadataUrl.isEmpty() ) { QDomElement metaUrlElem = doc.createElement( "MetadataURL" ); QString metadataUrlType = layer->metadataUrlType(); metaUrlElem.setAttribute( "type", metadataUrlType ); QString metadataUrlFormat = layer->metadataUrlFormat(); if ( metadataUrlFormat == "text/xml" ) { metaUrlElem.setAttribute( "format", "XML" ); } else { metaUrlElem.setAttribute( "format", "TXT" ); } QDomText metaUrlText = doc.createTextNode( metadataUrl ); metaUrlElem.appendChild( metaUrlText ); layerElem.appendChild( metaUrlElem ); } parentElement.appendChild( layerElem ); } }
LayerRenderJobs QgsMapRendererJob::prepareJobs( QPainter *painter, QgsLabelingEngine *labelingEngine2 ) { LayerRenderJobs layerJobs; // render all layers in the stack, starting at the base QListIterator<QgsMapLayer *> li( mSettings.layers() ); li.toBack(); if ( mCache ) { bool cacheValid = mCache->init( mSettings.visibleExtent(), mSettings.scale() ); Q_UNUSED( cacheValid ); QgsDebugMsgLevel( QString( "CACHE VALID: %1" ).arg( cacheValid ), 4 ); } bool requiresLabelRedraw = !( mCache && mCache->hasCacheImage( LABEL_CACHE_ID ) ); while ( li.hasPrevious() ) { QgsMapLayer *ml = li.previous(); QgsDebugMsgLevel( QString( "layer %1: minscale:%2 maxscale:%3 scaledepvis:%4 blendmode:%5" ) .arg( ml->name() ) .arg( ml->minimumScale() ) .arg( ml->maximumScale() ) .arg( ml->hasScaleBasedVisibility() ) .arg( ml->blendMode() ) , 3 ); if ( !ml->isInScaleRange( mSettings.scale() ) ) //|| mOverview ) { QgsDebugMsgLevel( "Layer not rendered because it is not within the defined visibility scale range", 3 ); continue; } QgsRectangle r1 = mSettings.visibleExtent(), r2; QgsCoordinateTransform ct; ct = mSettings.layerTransform( ml ); if ( ct.isValid() ) { reprojectToLayerExtent( ml, ct, r1, r2 ); } QgsDebugMsgLevel( "extent: " + r1.toString(), 3 ); if ( !r1.isFinite() || !r2.isFinite() ) { mErrors.append( Error( ml->id(), tr( "There was a problem transforming the layer's extent. Layer skipped." ) ) ); continue; } // Force render of layers that are being edited // or if there's a labeling engine that needs the layer to register features if ( mCache && ml->type() == QgsMapLayer::VectorLayer ) { QgsVectorLayer *vl = qobject_cast<QgsVectorLayer *>( ml ); bool requiresLabeling = false; requiresLabeling = ( labelingEngine2 && QgsPalLabeling::staticWillUseLayer( vl ) ) && requiresLabelRedraw; if ( vl->isEditable() || requiresLabeling ) { mCache->clearCacheImage( ml->id() ); } } layerJobs.append( LayerRenderJob() ); LayerRenderJob &job = layerJobs.last(); job.cached = false; job.img = nullptr; job.layer = ml; job.renderingTime = -1; job.context = QgsRenderContext::fromMapSettings( mSettings ); job.context.expressionContext().appendScope( QgsExpressionContextUtils::layerScope( ml ) ); job.context.setPainter( painter ); job.context.setLabelingEngine( labelingEngine2 ); job.context.setCoordinateTransform( ct ); job.context.setExtent( r1 ); if ( mFeatureFilterProvider ) job.context.setFeatureFilterProvider( mFeatureFilterProvider ); QgsMapLayerStyleOverride styleOverride( ml ); if ( mSettings.layerStyleOverrides().contains( ml->id() ) ) styleOverride.setOverrideStyle( mSettings.layerStyleOverrides().value( ml->id() ) ); job.blendMode = ml->blendMode(); job.opacity = 1.0; if ( QgsVectorLayer *vl = qobject_cast<QgsVectorLayer *>( ml ) ) { job.opacity = vl->opacity(); } // if we can use the cache, let's do it and avoid rendering! if ( mCache && mCache->hasCacheImage( ml->id() ) ) { job.cached = true; job.imageInitialized = true; job.img = new QImage( mCache->cacheImage( ml->id() ) ); job.renderer = nullptr; job.context.setPainter( nullptr ); continue; } // If we are drawing with an alternative blending mode then we need to render to a separate image // before compositing this on the map. This effectively flattens the layer and prevents // blending occurring between objects on the layer if ( mCache || !painter || needTemporaryImage( ml ) ) { // Flattened image for drawing when a blending mode is set QImage *mypFlattenedImage = nullptr; mypFlattenedImage = new QImage( mSettings.outputSize().width(), mSettings.outputSize().height(), mSettings.outputImageFormat() ); if ( mypFlattenedImage->isNull() ) { mErrors.append( Error( ml->id(), tr( "Insufficient memory for image %1x%2" ).arg( mSettings.outputSize().width() ).arg( mSettings.outputSize().height() ) ) ); delete mypFlattenedImage; layerJobs.removeLast(); continue; } job.img = mypFlattenedImage; QPainter *mypPainter = new QPainter( job.img ); mypPainter->setRenderHint( QPainter::Antialiasing, mSettings.testFlag( QgsMapSettings::Antialiasing ) ); job.context.setPainter( mypPainter ); } QTime layerTime; layerTime.start(); job.renderer = ml->createMapRenderer( job.context ); job.renderingTime = layerTime.elapsed(); // include job preparation time in layer rendering time } // while (li.hasPrevious()) return layerJobs; }
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 ) ); // TODO: expand all, collapse all // 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( actions->actionRemoveGroupOrLayer( menu ) ); menu->addAction( QgsApplication::getThemeIcon( "/mActionSetCRS.png" ), tr( "&Set Group CRS" ), QgisApp::instance(), SLOT( legendGroupSetCRS() ) ); menu->addAction( actions->actionRenameGroupOrLayer( menu ) ); if ( mView->selectedNodes( true ).count() >= 2 ) menu->addAction( actions->actionGroupSelected( menu ) ); menu->addAction( actions->actionAddGroup( menu ) ); } else if ( QgsLayerTree::isLayer( node ) ) { QgsMapLayer* layer = QgsLayerTree::toLayer( node )->layer(); menu->addAction( actions->actionZoomToLayer( mCanvas, menu ) ); menu->addAction( actions->actionShowInOverview( menu ) ); if ( layer && layer->type() == QgsMapLayer::RasterLayer ) { menu->addAction( tr( "&Zoom to Best Scale (100%)" ), QgisApp::instance(), SLOT( legendLayerZoomNative() ) ); QgsRasterLayer* rasterLayer = qobject_cast<QgsRasterLayer *>( layer ); if ( rasterLayer && rasterLayer->rasterType() != QgsRasterLayer::Palette ) menu->addAction( tr( "&Stretch Using Current Extent" ), QgisApp::instance(), SLOT( legendLayerStretchUsingCurrentExtent() ) ); } menu->addAction( actions->actionRemoveGroupOrLayer( menu ) ); // duplicate layer QAction* duplicateLayersAction = menu->addAction( QgsApplication::getThemeIcon( "/mActionDuplicateLayer.svg" ), tr( "&Duplicate" ), QgisApp::instance(), SLOT( duplicateLayers() ) ); // set layer scale visibility menu->addAction( tr( "&Set Layer Scale Visibility" ), QgisApp::instance(), SLOT( setLayerScaleVisibility() ) ); // 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() ) ); menu->addSeparator(); if ( layer && layer->type() == QgsMapLayer::VectorLayer ) { QgsVectorLayer* vlayer = qobject_cast<QgsVectorLayer *>( layer ); QAction *toggleEditingAction = QgisApp::instance()->actionToggleEditing(); QAction *saveLayerEditsAction = QgisApp::instance()->actionSaveActiveLayerEdits(); QAction *allEditsAction = QgisApp::instance()->actionAllEdits(); // attribute table menu->addAction( QgsApplication::getThemeIcon( "/mActionOpenTable.png" ), 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() ); } if ( saveLayerEditsAction && vlayer->isModified() ) { menu->addAction( saveLayerEditsAction ); } } if ( allEditsAction->isEnabled() ) menu->addAction( allEditsAction ); // disable duplication of memory layers if ( vlayer->storageType() == "Memory storage" && mView->selectedLayerNodes().count() == 1 ) duplicateLayersAction->setEnabled( false ); // save as vector file menu->addAction( tr( "Save As..." ), QgisApp::instance(), SLOT( saveAsFile() ) ); menu->addAction( tr( "Save As Layer Definition File..." ), QgisApp::instance(), SLOT( saveAsLayerDefinition() ) ); if ( !vlayer->isEditable() && vlayer->dataProvider()->supportsSubsetString() && vlayer->vectorJoins().isEmpty() ) menu->addAction( tr( "&Filter..." ), QgisApp::instance(), SLOT( layerSubsetString() ) ); menu->addAction( actions->actionShowFeatureCount( menu ) ); menu->addSeparator(); } else if ( layer && layer->type() == QgsMapLayer::RasterLayer ) { menu->addAction( tr( "Save As..." ), QgisApp::instance(), SLOT( saveAsRasterFile() ) ); menu->addAction( tr( "Save As Layer Definition File..." ), QgisApp::instance(), SLOT( saveAsLayerDefinition() ) ); } else if ( layer && layer->type() == QgsMapLayer::PluginLayer && mView->selectedLayerNodes().count() == 1 ) { // disable duplication of plugin layers duplicateLayersAction->setEnabled( false ); } // TODO: custom actions if ( layer && QgsProject::instance()->layerIsEmbedded( layer->id() ).isEmpty() ) menu->addAction( tr( "&Properties" ), QgisApp::instance(), SLOT( layerProperties() ) ); if ( node->parent() != mView->layerTreeModel()->rootGroup() ) menu->addAction( actions->actionMakeTopLevel( menu ) ); menu->addAction( actions->actionRenameGroupOrLayer( menu ) ); if ( mView->selectedNodes( true ).count() >= 2 ) menu->addAction( actions->actionGroupSelected( menu ) ); if ( mView->selectedLayerNodes().count() == 1 ) { QgisApp* app = QgisApp::instance(); menu->addAction( tr( "Copy Style" ), app, SLOT( copyStyle() ) ); if ( app->clipboard()->hasFormat( QGSCLIPBOARD_STYLE_MIME ) ) { menu->addAction( tr( "Paste Style" ), app, SLOT( pasteStyle() ) ); } } } } else { // symbology item? } return menu; }
void QgsMapToolIdentify::canvasReleaseEvent( QMouseEvent *e ) { if ( !mCanvas || mCanvas->isDrawing() ) { return; } results()->clear(); QSettings settings; int identifyMode = settings.value( "/Map/identifyMode", 0 ).toInt(); bool res = false; if ( identifyMode == 0 ) { QgsMapLayer *layer = mCanvas->currentLayer(); if ( !layer ) { QMessageBox::warning( mCanvas, tr( "No active layer" ), tr( "To identify features, you must choose an active layer by clicking on its name in the legend" ) ); return; } QApplication::setOverrideCursor( Qt::WaitCursor ); res = identifyLayer( layer, e->x(), e->y() ); QApplication::restoreOverrideCursor(); } else { connect( this, SIGNAL( identifyProgress( int, int ) ), QgisApp::instance(), SLOT( showProgress( int, int ) ) ); connect( this, SIGNAL( identifyMessage( QString ) ), QgisApp::instance(), SLOT( showStatusMessage( QString ) ) ); QApplication::setOverrideCursor( Qt::WaitCursor ); QStringList noIdentifyLayerIdList = QgsProject::instance()->readListEntry( "Identify", "/disabledLayers" ); for ( int i = 0; i < mCanvas->layerCount(); i++ ) { QgsMapLayer *layer = mCanvas->layer( i ); emit identifyProgress( i, mCanvas->layerCount() ); emit identifyMessage( tr( "Identifying on %1..." ).arg( layer->name() ) ); if ( noIdentifyLayerIdList.contains( layer->id() ) ) continue; if ( identifyLayer( layer, e->x(), e->y() ) ) { res = true; if ( identifyMode == 1 ) break; } } emit identifyProgress( mCanvas->layerCount(), mCanvas->layerCount() ); emit identifyMessage( tr( "Identifying done." ) ); disconnect( this, SIGNAL( identifyProgress( int, int ) ), QgisApp::instance(), SLOT( showProgress( int, int ) ) ); disconnect( this, SIGNAL( identifyMessage( QString ) ), QgisApp::instance(), SLOT( showStatusMessage( QString ) ) ); QApplication::restoreOverrideCursor(); } if ( res ) { results()->show(); } else { QSettings mySettings; bool myDockFlag = mySettings.value( "/qgis/dockIdentifyResults", false ).toBool(); if ( !myDockFlag ) { results()->hide(); } else { results()->clear(); } QgisApp::instance()->statusBar()->showMessage( tr( "No features at this position found." ) ); } }
void QgsOfflineEditing::synchronize() { // open logging db sqlite3* db = openLoggingDb(); if ( db == NULL ) { return; } emit progressStarted(); // restore and sync remote layers QList<QgsMapLayer*> offlineLayers; QMap<QString, QgsMapLayer*> mapLayers = QgsMapLayerRegistry::instance()->mapLayers(); for ( QMap<QString, QgsMapLayer*>::iterator layer_it = mapLayers.begin() ; layer_it != mapLayers.end(); ++layer_it ) { QgsMapLayer* layer = layer_it.value(); if ( layer->customProperty( CUSTOM_PROPERTY_IS_OFFLINE_EDITABLE, false ).toBool() ) { offlineLayers << layer; } } for ( int l = 0; l < offlineLayers.count(); l++ ) { QgsMapLayer* layer = offlineLayers[l]; emit layerProgressUpdated( l + 1, offlineLayers.count() ); QString remoteSource = layer->customProperty( CUSTOM_PROPERTY_REMOTE_SOURCE, "" ).toString(); QString remoteProvider = layer->customProperty( CUSTOM_PROPERTY_REMOTE_PROVIDER, "" ).toString(); QString remoteName = layer->name(); remoteName.remove( QRegExp( " \\(offline\\)$" ) ); QgsVectorLayer* remoteLayer = new QgsVectorLayer( remoteSource, remoteName, remoteProvider ); if ( remoteLayer->isValid() ) { // TODO: only add remote layer if there are log entries? QgsVectorLayer* offlineLayer = qobject_cast<QgsVectorLayer*>( layer ); // copy style copySymbology( offlineLayer, remoteLayer ); // register this layer with the central layers registry QgsMapLayerRegistry::instance()->addMapLayers( QList<QgsMapLayer *>() << remoteLayer, true ); // apply layer edit log QString qgisLayerId = layer->id(); QString sql = QString( "SELECT \"id\" FROM 'log_layer_ids' WHERE \"qgis_id\" = '%1'" ).arg( qgisLayerId ); int layerId = sqlQueryInt( db, sql, -1 ); if ( layerId != -1 ) { remoteLayer->startEditing(); // TODO: only get commitNos of this layer? int commitNo = getCommitNo( db ); for ( int i = 0; i < commitNo; i++ ) { // apply commits chronologically applyAttributesAdded( remoteLayer, db, layerId, i ); applyAttributeValueChanges( offlineLayer, remoteLayer, db, layerId, i ); applyGeometryChanges( remoteLayer, db, layerId, i ); } applyFeaturesAdded( offlineLayer, remoteLayer, db, layerId ); applyFeaturesRemoved( remoteLayer, db, layerId ); if ( remoteLayer->commitChanges() ) { // update fid lookup updateFidLookup( remoteLayer, db, layerId ); // clear edit log for this layer sql = QString( "DELETE FROM 'log_added_attrs' WHERE \"layer_id\" = %1" ).arg( layerId ); sqlExec( db, sql ); sql = QString( "DELETE FROM 'log_added_features' WHERE \"layer_id\" = %1" ).arg( layerId ); sqlExec( db, sql ); sql = QString( "DELETE FROM 'log_removed_features' WHERE \"layer_id\" = %1" ).arg( layerId ); sqlExec( db, sql ); sql = QString( "DELETE FROM 'log_feature_updates' WHERE \"layer_id\" = %1" ).arg( layerId ); sqlExec( db, sql ); sql = QString( "DELETE FROM 'log_geometry_updates' WHERE \"layer_id\" = %1" ).arg( layerId ); sqlExec( db, sql ); // reset commitNo QString sql = QString( "UPDATE 'log_indices' SET 'last_index' = 0 WHERE \"name\" = 'commit_no'" ); sqlExec( db, sql ); } else { showWarning( remoteLayer->commitErrors().join( "\n" ) ); } } // remove offline layer QgsMapLayerRegistry::instance()->removeMapLayers( ( QStringList() << qgisLayerId ) ); // disable offline project QString projectTitle = QgsProject::instance()->title(); projectTitle.remove( QRegExp( " \\(offline\\)$" ) ); QgsProject::instance()->title( projectTitle ); QgsProject::instance()->removeEntry( PROJECT_ENTRY_SCOPE_OFFLINE, PROJECT_ENTRY_KEY_OFFLINE_DB_PATH ); remoteLayer->reload(); //update with other changes } } emit progressStopped(); sqlite3_close( db ); }
void QgsWCSProjectParser::wcsContentMetadata( QDomElement& parentElement, QDomDocument& doc ) const { const QList<QDomElement>& projectLayerElements = mProjectParser.projectLayerElements(); if ( projectLayerElements.size() < 1 ) { return; } QStringList wcsLayersId = wcsLayers(); QMap<QString, QgsMapLayer *> layerMap; foreach ( const QDomElement &elem, projectLayerElements ) { QString type = elem.attribute( "type" ); if ( type == "raster" ) { QgsMapLayer *layer = mProjectParser.createLayerFromElement( elem ); if ( layer && wcsLayersId.contains( layer->id() ) ) { QgsDebugMsg( QString( "add layer %1 to map" ).arg( layer->id() ) ); layerMap.insert( layer->id(), layer ); QDomElement layerElem = doc.createElement( "CoverageOfferingBrief" ); QDomElement nameElem = doc.createElement( "name" ); //We use the layer name even though it might not be unique. //Because the id sometimes contains user/pw information and the name is more descriptive QString typeName = layer->name(); typeName = typeName.replace( " ", "_" ); QDomText nameText = doc.createTextNode( typeName ); nameElem.appendChild( nameText ); layerElem.appendChild( nameElem ); QDomElement labelElem = doc.createElement( "label" ); QString titleName = layer->title(); if ( titleName.isEmpty() ) { titleName = layer->name(); } QDomText labelText = doc.createTextNode( titleName ); labelElem.appendChild( labelText ); layerElem.appendChild( labelElem ); QDomElement descriptionElem = doc.createElement( "description" ); QString abstractName = layer->abstract(); if ( abstractName.isEmpty() ) { abstractName = ""; } QDomText descriptionText = doc.createTextNode( abstractName ); descriptionElem.appendChild( descriptionText ); layerElem.appendChild( descriptionElem ); //lonLatEnvelope const QgsCoordinateReferenceSystem& layerCrs = layer->crs(); QgsCoordinateTransform t( layerCrs, QgsCoordinateReferenceSystem( 4326 ) ); //transform QgsRectangle BBox = t.transformBoundingBox( layer->extent() ); QDomElement lonLatElem = doc.createElement( "lonLatEnvelope" ); lonLatElem.setAttribute( "srsName", "urn:ogc:def:crs:OGC:1.3:CRS84" ); QDomElement lowerPosElem = doc.createElement( "gml:pos" ); QDomText lowerPosText = doc.createTextNode( QString::number( BBox.xMinimum() ) + " " + QString::number( BBox.yMinimum() ) ); lowerPosElem.appendChild( lowerPosText ); lonLatElem.appendChild( lowerPosElem ); QDomElement upperPosElem = doc.createElement( "gml:pos" ); QDomText upperPosText = doc.createTextNode( QString::number( BBox.xMaximum() ) + " " + QString::number( BBox.yMaximum() ) ); upperPosElem.appendChild( upperPosText ); lonLatElem.appendChild( upperPosElem ); layerElem.appendChild( lonLatElem ); parentElement.appendChild( layerElem ); } } }
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; }
QList<QgsMapToolIdentify::IdentifyResult> QgsMapToolIdentify::identify( int x, int y, IdentifyMode mode, const QList<QgsMapLayer*>& layerList, const LayerType& layerType ) { QList<IdentifyResult> results; mLastPoint = mCanvas->getCoordinateTransform()->toMapCoordinates( x, y ); mLastExtent = mCanvas->extent(); mLastMapUnitsPerPixel = mCanvas->mapUnitsPerPixel(); if ( mode == DefaultQgsSetting ) { QSettings settings; mode = static_cast<IdentifyMode>( settings.value( "/Map/identifyMode", 0 ).toInt() ); } if ( mode == LayerSelection ) { QList<IdentifyResult> results = identify( x, y, TopDownAll, layerList, layerType ); QPoint globalPos = mCanvas->mapToGlobal( QPoint( x + 5, y + 5 ) ); return mIdentifyMenu->exec( results, globalPos ); } else if ( mode == ActiveLayer && layerList.isEmpty() ) { QgsMapLayer *layer = mCanvas->currentLayer(); if ( !layer ) { emit identifyMessage( tr( "No active layer. To identify features, you must choose an active layer." ) ); return results; } QApplication::setOverrideCursor( Qt::WaitCursor ); identifyLayer( &results, layer, mLastPoint, mLastExtent, mLastMapUnitsPerPixel, layerType ); } else { QApplication::setOverrideCursor( Qt::WaitCursor ); QStringList noIdentifyLayerIdList = QgsProject::instance()->readListEntry( "Identify", "/disabledLayers" ); int layerCount; if ( layerList.isEmpty() ) layerCount = mCanvas->layerCount(); else layerCount = layerList.count(); for ( int i = 0; i < layerCount; i++ ) { QgsMapLayer *layer; if ( layerList.isEmpty() ) layer = mCanvas->layer( i ); else layer = layerList.value( i ); emit identifyProgress( i, mCanvas->layerCount() ); emit identifyMessage( tr( "Identifying on %1..." ).arg( layer->name() ) ); if ( noIdentifyLayerIdList.contains( layer->id() ) ) continue; if ( identifyLayer( &results, layer, mLastPoint, mLastExtent, mLastMapUnitsPerPixel, layerType ) ) { if ( mode == TopDownStopAtFirst ) break; } } emit identifyProgress( mCanvas->layerCount(), mCanvas->layerCount() ); emit identifyMessage( tr( "Identifying done." ) ); } QApplication::restoreOverrideCursor(); return results; }
void QgsProjectParser::addLayers( QDomDocument &doc, QDomElement &parentElem, const QDomElement &legendElem, const QMap<QString, QgsMapLayer *> &layerMap, const QStringList &nonIdentifiableLayers ) const { QDomNodeList legendChildren = legendElem.childNodes(); for ( int i = 0; i < legendChildren.size(); ++i ) { QDomElement currentChildElem = legendChildren.at( i ).toElement(); QDomElement layerElem = doc.createElement( "Layer" ); if ( currentChildElem.tagName() == "legendgroup" ) { layerElem.setAttribute( "queryable", "1" ); QString name = currentChildElem.attribute( "name" ); QDomElement nameElem = doc.createElement( "Name" ); QDomText nameText = doc.createTextNode( name ); nameElem.appendChild( nameText ); layerElem.appendChild( nameElem ); QDomElement titleElem = doc.createElement( "Title" ); QDomText titleText = doc.createTextNode( name ); titleElem.appendChild( titleText ); layerElem.appendChild( titleElem ); if ( currentChildElem.attribute( "embedded" ) == "1" ) { //add layers from other project files and embed into this group QString project = convertToAbsolutePath( currentChildElem.attribute( "project" ) ); QgsDebugMsg( QString( "Project path: %1" ).arg( project ) ); QString embeddedGroupName = currentChildElem.attribute( "name" ); QgsProjectParser* p = dynamic_cast<QgsProjectParser*>( QgsConfigCache::instance()->searchConfiguration( project ) ); if ( p ) { QStringList pIdDisabled = p->identifyDisabledLayers(); QDomElement embeddedGroupElem; QList<QDomElement> pLegendElems = p->legendGroupElements(); QList<QDomElement>::const_iterator pLegendIt = pLegendElems.constBegin(); for ( ; pLegendIt != pLegendElems.constEnd(); ++pLegendIt ) { if ( pLegendIt->attribute( "name" ) == embeddedGroupName ) { embeddedGroupElem = *pLegendIt; break; } } QList<QDomElement> pLayerElems = p->projectLayerElements(); QMap<QString, QgsMapLayer *> pLayerMap; QList<QDomElement>::const_iterator pLayerIt = pLayerElems.constBegin(); for ( ; pLayerIt != pLayerElems.constEnd(); ++pLayerIt ) { pLayerMap.insert( layerId( *pLayerIt ), p->createLayerFromElement( *pLayerIt ) ); } p->addLayers( doc, layerElem, embeddedGroupElem, pLayerMap, pIdDisabled ); } } else //normal (not embedded) legend group { addLayers( doc, layerElem, currentChildElem, layerMap, nonIdentifiableLayers ); } // combine bounding boxes of children (groups/layers) combineExtentAndCrsOfGroupChildren( layerElem, doc ); } else if ( currentChildElem.tagName() == "legendlayer" ) { QString id = layerIdFromLegendLayer( currentChildElem ); if ( !layerMap.contains( id ) ) { QgsDebugMsg( QString( "layer %1 not found in map - layer cache to small?" ).arg( id ) ); continue; } QgsMapLayer *currentLayer = layerMap[ id ]; if ( !currentLayer ) { QgsDebugMsg( QString( "layer %1 not found" ).arg( id ) ); continue; } if ( nonIdentifiableLayers.contains( currentLayer->id() ) ) { layerElem.setAttribute( "queryable", "0" ); } else { layerElem.setAttribute( "queryable", "1" ); } QDomElement nameElem = doc.createElement( "Name" ); //We use the layer name even though it might not be unique. //Because the id sometimes contains user/pw information and the name is more descriptive QDomText nameText = doc.createTextNode( currentLayer->name() ); nameElem.appendChild( nameText ); layerElem.appendChild( nameElem ); QDomElement titleElem = doc.createElement( "Title" ); QDomText titleText = doc.createTextNode( currentLayer->name() ); titleElem.appendChild( titleText ); layerElem.appendChild( titleElem ); //CRS QStringList crsList = createCRSListForLayer( currentLayer ); appendCRSElementsToLayer( layerElem, doc, crsList ); //Ex_GeographicBoundingBox appendLayerBoundingBoxes( layerElem, doc, currentLayer->extent(), currentLayer->crs() ); //only one default style in project file mode QDomElement styleElem = doc.createElement( "Style" ); QDomElement styleNameElem = doc.createElement( "Name" ); QDomText styleNameText = doc.createTextNode( "default" ); styleNameElem.appendChild( styleNameText ); QDomElement styleTitleElem = doc.createElement( "Title" ); QDomText styleTitleText = doc.createTextNode( "default" ); styleTitleElem.appendChild( styleTitleText ); styleElem.appendChild( styleNameElem ); styleElem.appendChild( styleTitleElem ); layerElem.appendChild( styleElem ); } else { QgsDebugMsg( "unexpected child element" ); continue; } parentElem.appendChild( layerElem ); } }