void QgsGeometrySnapperDialog::validateInput() { QgsVectorLayer* inLayer = getInputLayer(); QgsVectorLayer* refLayer = getReferenceLayer(); bool outputOk = ui.radioButtonOuputModifyInput->isChecked() || !ui.lineEditOutput->text().isEmpty(); mRunButton->setEnabled( inLayer != 0 && refLayer != 0 && inLayer != refLayer && refLayer->geometryType() == inLayer->geometryType() && outputOk ); }
HeatmapGui::HeatmapGui( QWidget* parent, Qt::WindowFlags fl, QMap<QString, QVariant>* temporarySettings ) : QDialog( parent, fl ), mRows( 500 ) { setupUi( this ); QgsDebugMsg( QString( "Creating Heatmap Dialog" ) ); blockAllSignals( true ); mHeatmapSessionSettings = temporarySettings; // Adding point layers to the inputLayerCombo QString defaultLayer = mHeatmapSessionSettings->value( QString( "lastInputLayer" ) ).toString(); int defaultLayerIndex = 0; bool usingLastInputLayer = false; int currentIndex = -1; foreach ( QgsMapLayer *l, QgsMapLayerRegistry::instance()->mapLayers() ) { QgsVectorLayer *vl = qobject_cast<QgsVectorLayer *>( l ); if ( !vl || vl->geometryType() != QGis::Point ) continue; currentIndex++; inputLayerCombo->addItem( vl->name(), vl->id() ); if ( vl->id() == defaultLayer ) { // if this layer is the same layer as a heatmap was last generated using, // then default to this layer usingLastInputLayer = true; defaultLayerIndex = currentIndex; } }
void QgsMapToolNodeTool::canvasPressEvent( QMouseEvent * e ) { QgsDebugCall; mClicked = true; mPressCoordinates = e->pos(); QList<QgsSnappingResult> snapResults; if ( !mSelectedFeature ) { QgsVectorLayer *vlayer = qobject_cast<QgsVectorLayer *>( mCanvas->currentLayer() ); if ( !vlayer ) return; mSelectAnother = false; mSnapper.snapToCurrentLayer( e->pos(), snapResults, QgsSnapper::SnapToVertexAndSegment, -1 ); if ( snapResults.size() < 1 ) { displaySnapToleranceWarning(); return; } mSelectedFeature = new QgsSelectedFeature( snapResults[0].snappedAtGeometry, vlayer, mCanvas ); connect( QgisApp::instance()->legend(), SIGNAL( currentLayerChanged( QgsMapLayer* ) ), this, SLOT( currentLayerChanged( QgsMapLayer* ) ) ); connect( mSelectedFeature, SIGNAL( destroyed() ), this, SLOT( selectedFeatureDestroyed() ) ); mIsPoint = vlayer->geometryType() == QGis::Point; }
void QgsComposerTableWidget::changeLayer( QgsMapLayer *layer ) { if ( !mComposerTable ) { return; } QgsVectorLayer* vl = dynamic_cast<QgsVectorLayer*>( layer ); if ( !vl ) { return; } mComposerTable->beginCommand( tr( "Table layer changed" ) ); mComposerTable->setVectorLayer( vl ); mComposerTable->update(); mComposerTable->endCommand(); if ( vl->geometryType() == QGis::NoGeometry ) { //layer has no geometry, so uncheck & disable controls which require geometry mShowOnlyVisibleFeaturesCheckBox->setChecked( false ); mShowOnlyVisibleFeaturesCheckBox->setEnabled( false ); } else { mShowOnlyVisibleFeaturesCheckBox->setEnabled( true ); } }
void rulesDialog::updateRuleItems( const QString &layerName ) { if ( layerName.isEmpty() ) { return; } mRuleBox->clear(); if ( layerName == tr( "No layer" ) ) { return; } QString layerId = mLayer1Box->currentData().toString(); QgsVectorLayer* vlayer = ( QgsVectorLayer* )QgsProject::instance()->mapLayer( layerId ); if ( !vlayer ) { qDebug() << "not a vector layer"; return; } for ( QMap<QString, TopologyRule>::iterator it = mTestConfMap.begin(); it != mTestConfMap.end(); ++it ) { TopologyRule& rule = it.value(); if ( rule.layer1AcceptsType( vlayer->geometryType() ) ) { mRuleBox->addItem( it.key() ); } } }
void QgsMapToolNodeTool::canvasPressEvent( QMouseEvent * e ) { QgsDebugCall; mClicked = true; mPressCoordinates = e->pos(); if ( !mSelectedFeature ) { QgsVectorLayer *vlayer = qobject_cast<QgsVectorLayer *>( mCanvas->currentLayer() ); if ( !vlayer ) return; mSelectAnother = false; QgsPointLocator::Match m = mCanvas->snappingUtils()->snapToCurrentLayer( e->pos(), QgsPointLocator::Vertex | QgsPointLocator::Edge ); if ( !m.isValid() ) { emit messageEmitted( tr( "could not snap to a segment on the current layer." ) ); return; } // remove previous warning emit messageDiscarded(); mSelectedFeature = new QgsSelectedFeature( m.featureId(), vlayer, mCanvas ); connect( QgisApp::instance()->layerTreeView(), SIGNAL( currentLayerChanged( QgsMapLayer* ) ), this, SLOT( currentLayerChanged( QgsMapLayer* ) ) ); connect( mSelectedFeature, SIGNAL( destroyed() ), this, SLOT( selectedFeatureDestroyed() ) ); connect( vlayer, SIGNAL( editingStopped() ), this, SLOT( editingToggled() ) ); mIsPoint = vlayer->geometryType() == QGis::Point; }
void QgsMapToolCapture::currentLayerChanged( QgsMapLayer *layer ) { if ( !mCaptureModeFromLayer ) return; mCaptureMode = CaptureNone; QgsVectorLayer *vlayer = qobject_cast<QgsVectorLayer *>( layer ); if ( !vlayer ) { return; } switch ( vlayer->geometryType() ) { case QgsWkbTypes::PointGeometry: mCaptureMode = CapturePoint; break; case QgsWkbTypes::LineGeometry: mCaptureMode = CaptureLine; break; case QgsWkbTypes::PolygonGeometry: mCaptureMode = CapturePolygon; break; default: mCaptureMode = CaptureNone; break; } }
void QgsZonalStatisticsDialog::insertAvailableLayers() { //insert available raster layers //enter available layers into the combo box QMap<QString, QgsMapLayer*> mapLayers = QgsMapLayerRegistry::instance()->mapLayers(); QMap<QString, QgsMapLayer*>::iterator layer_it = mapLayers.begin(); for ( ; layer_it != mapLayers.end(); ++layer_it ) { QgsRasterLayer* rl = dynamic_cast<QgsRasterLayer*>( layer_it.value() ); if ( rl ) { QgsRasterDataProvider* rp = rl->dataProvider(); if ( rp && rp->name() == "gdal" ) { mRasterLayerComboBox->addItem( rl->name(), QVariant( rl->id() ) ); } } else { QgsVectorLayer* vl = dynamic_cast<QgsVectorLayer*>( layer_it.value() ); if ( vl && vl->geometryType() == QGis::Polygon ) { QgsVectorDataProvider* provider = vl->dataProvider(); if ( provider->capabilities() & QgsVectorDataProvider::AddAttributes ) { mPolygonLayerComboBox->addItem( vl->name(), QVariant( vl->id() ) ); } } } } }
void QgsMapToolNodeTool::canvasPressEvent( QMouseEvent * e ) { QgsDebugCall; mClicked = true; mPressCoordinates = e->pos(); QList<QgsSnappingResult> snapResults; if ( !mSelectedFeature ) { QgsVectorLayer *vlayer = qobject_cast<QgsVectorLayer *>( mCanvas->currentLayer() ); if ( !vlayer ) return; mSelectAnother = false; mSnapper.snapToCurrentLayer( e->pos(), snapResults, QgsSnapper::SnapToVertexAndSegment, -1 ); if ( snapResults.size() < 1 ) { emit messageEmitted( tr( "could not snap to a segment on the current layer." ) ); return; } // remove previous warning emit messageDiscarded(); mSelectedFeature = new QgsSelectedFeature( snapResults[0].snappedAtGeometry, vlayer, mCanvas ); connect( QgisApp::instance()->layerTreeView(), SIGNAL( currentLayerChanged( QgsMapLayer* ) ), this, SLOT( currentLayerChanged( QgsMapLayer* ) ) ); connect( mSelectedFeature, SIGNAL( destroyed() ), this, SLOT( selectedFeatureDestroyed() ) ); connect( vlayer, SIGNAL( editingStopped() ), this, SLOT( editingToggled() ) ); mIsPoint = vlayer->geometryType() == QGis::Point; }
int QgsUniqueValueRenderer::readXML( const QDomNode& rnode, QgsVectorLayer& vl ) { mGeometryType = vl.geometryType(); QDomNode classnode = rnode.namedItem( "classificationfield" ); QString classificationField = classnode.toElement().text(); QgsVectorDataProvider* theProvider = vl.dataProvider(); if ( !theProvider ) { return 1; } int classificationId = vl.fieldNameIndex( classificationField ); if ( classificationId == -1 ) { //go on. Because with joins, it might be the joined layer is not loaded yet } setClassificationField( classificationId ); QDomNode symbolnode = rnode.namedItem( "symbol" ); while ( !symbolnode.isNull() ) { QgsSymbol* msy = new QgsSymbol( mGeometryType ); msy->readXML( symbolnode, &vl ); insertValue( msy->lowerValue(), msy ); symbolnode = symbolnode.nextSibling(); } updateSymbolAttributes(); vl.setRenderer( this ); return 0; }
void QgsMapToolAddRegularPolygon::clean() { if ( mTempRubberBand ) { delete mTempRubberBand; mTempRubberBand = nullptr; } mPoints.clear(); if ( mParentTool ) { mParentTool->deleteTempRubberBand(); } if ( mNumberSidesSpinBox ) { deleteNumberSidesSpinBox(); } mRegularPolygon = QgsRegularPolygon(); QgsVectorLayer *vLayer = static_cast<QgsVectorLayer *>( QgisApp::instance()->activeLayer() ); if ( vLayer ) mLayerType = vLayer->geometryType(); }
bool QgsMapToolRotatePointSymbols::layerIsRotatable( QgsMapLayer* ml ) { if ( !ml ) { return false; } //a vector layer QgsVectorLayer* vLayer = qobject_cast<QgsVectorLayer *>( ml ); if ( !vLayer ) { return false; } //does it have point or multipoint type? if ( vLayer->geometryType() != QGis::Point ) { return false; } //does it have a least one rotation attribute? QList<int> rotationAttributes; layerRotationAttributes( vLayer, rotationAttributes ); if ( rotationAttributes.size() < 1 ) { return false; } return true; }
bool QgsMapLayerProxyModel::filterAcceptsRow( int source_row, const QModelIndex &source_parent ) const { if ( mFilters.testFlag( All ) && mExceptList.isEmpty() ) return true; QModelIndex index = sourceModel()->index( source_row, 0, source_parent ); QgsMapLayer* layer = static_cast<QgsMapLayer*>( index.internalPointer() ); if ( !layer ) return false; if ( mExceptList.contains( layer ) ) return false; // layer type if (( mFilters.testFlag( RasterLayer ) && layer->type() == QgsMapLayer::RasterLayer ) || ( mFilters.testFlag( VectorLayer ) && layer->type() == QgsMapLayer::VectorLayer ) || ( mFilters.testFlag( PluginLayer ) && layer->type() == QgsMapLayer::PluginLayer ) ) return true; // geometry type bool detectGeometry = mFilters.testFlag( NoGeometry ) || mFilters.testFlag( PointLayer ) || mFilters.testFlag( LineLayer ) || mFilters.testFlag( PolygonLayer ) || mFilters.testFlag( HasGeometry ); if ( detectGeometry && layer->type() == QgsMapLayer::VectorLayer ) { QgsVectorLayer* vl = dynamic_cast<QgsVectorLayer*>( layer ); if ( vl ) { if ( mFilters.testFlag( HasGeometry ) && vl->hasGeometryType() ) return true; if ( mFilters.testFlag( NoGeometry ) && vl->geometryType() == QGis::NoGeometry ) return true; if ( mFilters.testFlag( PointLayer ) && vl->geometryType() == QGis::Point ) return true; if ( mFilters.testFlag( LineLayer ) && vl->geometryType() == QGis::Line ) return true; if ( mFilters.testFlag( PolygonLayer ) && vl->geometryType() == QGis::Polygon ) return true; } } return false; }
void QgsMapToolRotateFeature::canvasReleaseEvent( QMouseEvent * e ) { Q_UNUSED( e ); if ( !mRubberBand ) { return; } QgsVectorLayer* vlayer = currentVectorLayer(); if ( !vlayer ) { return; } //calculations for affine transformation double angle = -1 * mRotation * ( PI / 180 ); QgsPoint anchorPoint = toLayerCoordinates( vlayer, mStartPointMapCoords ); double a = cos( angle ); double b = -1 * sin( angle ); double c = anchorPoint.x() - cos( angle ) * anchorPoint.x() + sin( angle ) * anchorPoint.y(); double d = sin( angle ); double ee = cos( angle ); double f = anchorPoint.y() - sin( angle ) * anchorPoint.x() - cos( angle ) * anchorPoint.y(); vlayer->beginEditCommand( tr( "Features Rotated" ) ); int start; if ( vlayer->geometryType() == 2 ) { start = 1; } else { start = 0; } int i = 0; foreach ( QgsFeatureId id, mRotatedFeatures ) { QgsFeature feat; vlayer->getFeatures( QgsFeatureRequest().setFilterFid( id ) ).nextFeature( feat ); QgsGeometry* geom = feat.geometry(); i = start; QgsPoint vertex = geom->vertexAt( i ); while ( vertex != QgsPoint( 0, 0 ) ) { double newX = a * vertex.x() + b * vertex.y() + c; double newY = d * vertex.x() + ee * vertex.y() + f; vlayer->moveVertex( newX, newY, id, i ); i = i + 1; vertex = geom->vertexAt( i ); } }
void QgsVectorLayer3DRendererWidget::setRenderer( const QgsVectorLayer3DRenderer *renderer ) { mRenderer.reset( renderer ? renderer->clone() : nullptr ); whileBlocking( chkEnabled )->setChecked( ( bool )mRenderer ); widgetLine->setEnabled( chkEnabled->isChecked() ); widgetPoint->setEnabled( chkEnabled->isChecked() ); widgetPolygon->setEnabled( chkEnabled->isChecked() ); int pageIndex; QgsVectorLayer *vlayer = qobject_cast<QgsVectorLayer *>( mLayer ); switch ( vlayer->geometryType() ) { case QgsWkbTypes::PointGeometry: pageIndex = 2; if ( mRenderer && mRenderer->symbol() && mRenderer->symbol()->type() == "point" ) { whileBlocking( widgetPoint )->setSymbol( *static_cast<const QgsPoint3DSymbol *>( mRenderer->symbol() ) ); } else { whileBlocking( widgetPoint )->setSymbol( QgsPoint3DSymbol() ); } break; case QgsWkbTypes::LineGeometry: pageIndex = 1; if ( mRenderer && mRenderer->symbol() && mRenderer->symbol()->type() == "line" ) { whileBlocking( widgetLine )->setSymbol( *static_cast<const QgsLine3DSymbol *>( mRenderer->symbol() ) ); } else { whileBlocking( widgetLine )->setSymbol( QgsLine3DSymbol() ); } break; case QgsWkbTypes::PolygonGeometry: pageIndex = 3; if ( mRenderer && mRenderer->symbol() && mRenderer->symbol()->type() == "polygon" ) { whileBlocking( widgetPolygon )->setSymbol( *static_cast<const QgsPolygon3DSymbol *>( mRenderer->symbol() ) ); } else { whileBlocking( widgetPolygon )->setSymbol( QgsPolygon3DSymbol() ); } break; default: pageIndex = 0; // unsupported break; } widgetStack->setCurrentIndex( pageIndex ); }
void QgsMapToolRotateFeature::applyRotation( double rotation ) { mRotation = rotation; mRotationActive = false; QgsVectorLayer *vlayer = currentVectorLayer(); if ( !vlayer ) { deleteRubberband(); notifyNotVectorLayer(); return; } //calculations for affine transformation double angle = -1 * mRotation * ( M_PI / 180 ); QgsPointXY anchorPoint = toLayerCoordinates( vlayer, mStartPointMapCoords ); double a = std::cos( angle ); double b = -1 * std::sin( angle ); double c = anchorPoint.x() - std::cos( angle ) * anchorPoint.x() + std::sin( angle ) * anchorPoint.y(); double d = std::sin( angle ); double ee = std::cos( angle ); double f = anchorPoint.y() - std::sin( angle ) * anchorPoint.x() - std::cos( angle ) * anchorPoint.y(); vlayer->beginEditCommand( tr( "Features Rotated" ) ); int start; if ( vlayer->geometryType() == 2 ) { start = 1; } else { start = 0; } int i = 0; Q_FOREACH ( QgsFeatureId id, mRotatedFeatures ) { QgsFeature feat; vlayer->getFeatures( QgsFeatureRequest().setFilterFid( id ) ).nextFeature( feat ); QgsGeometry geom = feat.geometry(); i = start; QgsPointXY vertex = geom.vertexAt( i ); while ( vertex != QgsPointXY( 0, 0 ) ) { double newX = a * vertex.x() + b * vertex.y() + c; double newY = d * vertex.x() + ee * vertex.y() + f; vlayer->moveVertex( newX, newY, id, i ); i = i + 1; vertex = geom.vertexAt( i ); } }
void QgsMapToolAddFeature::activate() { QgsVectorLayer *vlayer = qobject_cast<QgsVectorLayer *>( mCanvas->currentLayer() ); if ( vlayer && vlayer->geometryType() == QGis::NoGeometry ) { QgsFeature f; addFeature( vlayer, &f, false ); return; } QgsMapToolCapture::activate(); }
int QgsContinuousColorRenderer::readXML( const QDomNode& rnode, QgsVectorLayer& vl ) { mGeometryType = vl.geometryType(); QDomNode classnode = rnode.namedItem( "classificationfield" ); QString classificationField = classnode.toElement().text(); QgsVectorDataProvider* theProvider = vl.dataProvider(); if ( !theProvider ) { return 1; } int classificationId = vl.fieldNameIndex( classificationField ); if ( classificationId == -1 ) { //go on. Because with joins, it might be the joined layer is not loaded yet } setClassificationField( classificationId ); //polygon outline QDomNode polyoutlinenode = rnode.namedItem( "polygonoutline" ); QString polyoutline = polyoutlinenode.toElement().text(); if ( polyoutline == "0" ) { mDrawPolygonOutline = false; } else if ( polyoutline == "1" ) { mDrawPolygonOutline = true; } //read the settings for the renderitem of the minimum value QDomNode lowernode = rnode.namedItem( "lowestsymbol" ); QDomNode lsymbolnode = lowernode.namedItem( "symbol" ); if ( ! lsymbolnode.isNull() ) { QgsSymbol* lsy = new QgsSymbol( mGeometryType ); lsy->readXML( lsymbolnode, &vl ); setMinimumSymbol( lsy ); } QDomNode uppernode = rnode.namedItem( "highestsymbol" ); QDomNode usymbolnode = uppernode.namedItem( "symbol" ); if ( ! usymbolnode.isNull() ) { QgsSymbol* usy = new QgsSymbol( mGeometryType ); usy->readXML( usymbolnode, &vl ); setMaximumSymbol( usy ); } vl.setRenderer( this ); return 0; }
HeatmapGui::HeatmapGui( QWidget* parent, Qt::WFlags fl ) : QDialog( parent, fl ) { setupUi( this ); // Adding point layers to the mInputVectorCombo foreach( QgsMapLayer *l, QgsMapLayerRegistry::instance()->mapLayers() ) { QgsVectorLayer *vl = qobject_cast<QgsVectorLayer *>( l ); if ( !vl || vl->geometryType() != QGis::Point ) continue; mInputVectorCombo->addItem( vl->name(), vl->id() ); }
int QgsGraduatedSymbolRenderer::readXML( const QDomNode& rnode, QgsVectorLayer& vl ) { mGeometryType = vl.geometryType(); QDomNode modeNode = rnode.namedItem( "mode" ); QString modeValue = modeNode.toElement().text(); QDomNode classnode = rnode.namedItem( "classificationfield" ); QString classificationField = classnode.toElement().text(); QgsVectorDataProvider* theProvider = vl.dataProvider(); if ( !theProvider ) { return 1; } if ( modeValue == "Empty" ) { mMode = QgsGraduatedSymbolRenderer::Empty; } else if ( modeValue == "Quantile" ) { mMode = QgsGraduatedSymbolRenderer::Quantile; } else //default { mMode = QgsGraduatedSymbolRenderer::EqualInterval; } int classificationId = vl.fieldNameIndex( classificationField ); if ( classificationId == -1 ) { //go on. Because with joins, it might be the joined layer is not loaded yet } setClassificationField( classificationId ); QDomNode symbolnode = rnode.namedItem( "symbol" ); while ( !symbolnode.isNull() ) { QgsSymbol* sy = new QgsSymbol( mGeometryType ); sy->readXML( symbolnode, &vl ); addSymbol( sy ); symbolnode = symbolnode.nextSibling(); } updateSymbolAttributes(); vl.setRenderer( this ); return 0; }
void QgsMapToolAddFeature::activate() { if ( !mCanvas || mCanvas->isDrawing() ) { return; } QgsVectorLayer *vlayer = qobject_cast<QgsVectorLayer *>( mCanvas->currentLayer() ); if ( vlayer && vlayer->geometryType() == QGis::NoGeometry ) { QgsFeature f; addFeature( vlayer, &f ); return; } QgsMapTool::activate(); }
QPixmap QgsLegendLayer::getOriginalPixmap() { QgsMapLayer* theLayer = layer(); if ( theLayer ) { if ( theLayer->type() == QgsMapLayer::VectorLayer ) { QgsVectorLayer* vlayer = qobject_cast<QgsVectorLayer *>( theLayer ); switch ( vlayer->geometryType() ) { case QGis::Point: return QgisApp::getThemePixmap( "/mIconPointLayer.png" ); break; case QGis::Line: return QgisApp::getThemePixmap( "/mIconLineLayer.png" ); break; case QGis::Polygon: return QgisApp::getThemePixmap( "/mIconPolygonLayer.png" ); break; case QGis::NoGeometry: return QgisApp::getThemePixmap( "/mIconTableLayer.png" ); default: return QgisApp::getThemePixmap( "/mIconLayer.png" ); } } else if ( theLayer->type() == QgsMapLayer::RasterLayer ) { QSettings s; if ( s.value( "/qgis/createRasterLegendIcons", true ).toBool() ) { QgsRasterLayer* rlayer = qobject_cast<QgsRasterLayer *>( theLayer ); QPixmap myPixmap( 32, 32 ); rlayer->thumbnailAsPixmap( &myPixmap ); return myPixmap; } else { return QPixmap(); } } } // undefined - should never reach this return QgisApp::getThemePixmap( "/mIconLayer.png" ); }
int QgsGraduatedSymbolRenderer::readXML( const QDomNode& rnode, QgsVectorLayer& vl ) { mGeometryType = vl.geometryType(); QDomNode modeNode = rnode.namedItem( "mode" ); QString modeValue = modeNode.toElement().text(); QDomNode classnode = rnode.namedItem( "classificationfield" ); QString classificationField = classnode.toElement().text(); QgsVectorDataProvider* theProvider = vl.dataProvider(); if ( !theProvider ) { return 1; } if ( modeValue == "Empty" ) { mMode = QgsGraduatedSymbolRenderer::Empty; } else if ( modeValue == "Quantile" ) { mMode = QgsGraduatedSymbolRenderer::Quantile; } else //default { mMode = QgsGraduatedSymbolRenderer::EqualInterval; } int classificationId = theProvider->fieldNameIndex( classificationField ); if ( classificationId == -1 ) { return 2; //@todo: handle gracefully in gui situation where user needs to nominate field } setClassificationField( classificationId ); QDomNode symbolnode = rnode.namedItem( "symbol" ); while ( !symbolnode.isNull() ) { QgsSymbol* sy = new QgsSymbol( mGeometryType ); sy->readXML( symbolnode, &vl ); addSymbol( sy ); symbolnode = symbolnode.nextSibling(); } updateSymbolAttributes(); vl.setRenderer( this ); return 0; }
int main(int argc, char ** argv) { // Start the Application QgsApplication app(argc, argv, true); QString myPluginsDir = "/home/timlinux/apps/lib/qgis"; QString myLayerPath = "/home/timlinux/gisdata/brazil/BR_Cidades/"; QString myLayerBaseName = "Brasil_Cap"; QString myProviderName = "ogr"; // Instantiate Provider Registry QgsProviderRegistry::instance(myPluginsDir); // create a maplayer instance QgsVectorLayer * mypLayer = new QgsVectorLayer(myLayerPath, myLayerBaseName, myProviderName); QgsSingleSymbolRenderer *mypRenderer = new QgsSingleSymbolRenderer(mypLayer->geometryType()); QList <QgsMapCanvasLayer> myLayerSet; mypLayer->setRenderer(mypRenderer); if (mypLayer->isValid()) { qDebug("Layer is valid"); } else { qDebug("Layer is NOT valid"); } // Add the Vector Layer to the Layer Registry QgsMapLayerRegistry::instance()->addMapLayer(mypLayer, TRUE); // Add the Layer to the Layer Set myLayerSet.append(QgsMapCanvasLayer(mypLayer, TRUE)); // Create the Map Canvas QgsMapCanvas * mypMapCanvas = new QgsMapCanvas(0, 0); mypMapCanvas->setExtent(mypLayer->extent()); mypMapCanvas->enableAntiAliasing(true); mypMapCanvas->setCanvasColor(QColor(255, 255, 255)); mypMapCanvas->freeze(false); // Set the Map Canvas Layer Set mypMapCanvas->setLayerSet(myLayerSet); mypMapCanvas->setVisible(true); mypMapCanvas->refresh(); // Start the Application Event Loop return app.exec(); }
QgsVectorLayer* RgLineVectorLayerSettingsWidget::selectedLayer() { QMap<QString, QgsMapLayer*> mapLayers = QgsMapLayerRegistry::instance()->mapLayers(); QMap<QString, QgsMapLayer*>::iterator layer_it = mapLayers.begin(); for ( ; layer_it != mapLayers.end(); ++layer_it ) { QgsVectorLayer* vl = dynamic_cast<QgsVectorLayer*>( layer_it.value() ); if ( !vl ) continue; if ( vl->geometryType() != QGis::Line ) continue; if ( vl->name() == mcbLayers->currentText() ) return vl; } return NULL; } // RgLineVectorLayerSettingsWidget::setlectedLayer()
//MODEL QList<QgsVectorLayer*> QgsGlobePluginDialog::pointLayers() { QList<QgsVectorLayer*> list; QMap< QString, QgsMapLayer *> layers = QgsMapLayerRegistry::instance()->mapLayers(); QMapIterator<QString, QgsMapLayer *> it( layers ); while ( it.hasNext() ) { it.next(); QgsMapLayer* layer = it.value(); if ( layer->type() == QgsMapLayer::VectorLayer ) { QgsVectorLayer* vectorLayer = static_cast<QgsVectorLayer*>( layer ); if ( vectorLayer->geometryType() == QGis::Point ) { list.append( vectorLayer ); } } } return list; }
QPixmap QgsLegendLayer::getOriginalPixmap() { QgsMapLayer* theLayer = layer(); if ( theLayer ) { if ( theLayer->type() == QgsMapLayer::VectorLayer ) { QgsVectorLayer* vlayer = qobject_cast<QgsVectorLayer *>( theLayer ); switch ( vlayer->geometryType() ) { case QGis::Point: return QgsApplication::getThemePixmap( "/mIconPointLayer.svg" ); case QGis::Line: return QgsApplication::getThemePixmap( "/mIconLineLayer.svg" ); case QGis::Polygon: return QgsApplication::getThemePixmap( "/mIconPolygonLayer.svg" ); case QGis::NoGeometry: return QgsApplication::getThemePixmap( "/mIconTableLayer.png" ); default: return QgsApplication::getThemePixmap( "/mIconLayer.png" ); } } else if ( theLayer->type() == QgsMapLayer::RasterLayer ) { QSettings s; if ( s.value( "/qgis/createRasterLegendIcons", false ).toBool() ) { QgsRasterLayer* rlayer = qobject_cast<QgsRasterLayer *>( theLayer ); return rlayer->previewAsPixmap( QSize( 32, 32 ) ); } else { return QgsApplication::getThemePixmap( "/mIconRasterLayer.svg" ); } } } // undefined - should never reach this return QgsApplication::getThemePixmap( "/mIconLayer.png" ); }
void QgsComposerSymbolItem::readXML( const QDomElement& itemElem ) { if ( itemElem.isNull() ) { return; } setText( itemElem.attribute( "text", "" ) ); setLayerID( itemElem.attribute( "layerId", "" ) ); QgsVectorLayer* vLayer = qobject_cast<QgsVectorLayer*>( QgsMapLayerRegistry::instance()->mapLayer( mLayerID ) ); if ( vLayer ) { QDomElement symbolElem = itemElem.firstChildElement( "symbol" ); if ( !symbolElem.isNull() ) { QgsSymbol* symbol = new QgsSymbol( vLayer->geometryType() ); symbol->readXML( symbolElem, vLayer ); setSymbol( symbol ); //add icon switch ( symbol->type() ) { case QGis::Point: setIcon( QIcon( QPixmap::fromImage( symbol->getPointSymbolAsImage() ) ) ); break; case QGis::Line: setIcon( QIcon( QPixmap::fromImage( symbol->getLineSymbolAsImage() ) ) ); break; case QGis::Polygon: setIcon( QIcon( QPixmap::fromImage( symbol->getPolygonSymbolAsImage() ) ) ); break; case QGis::NoGeometry: setIcon( QIcon( QgsApplication::activeThemePath() + "/mIconTableLayer.png" ) ); break; case QGis::UnknownGeometry: // should not occur break; } } } }
void QgsMapToolAddCircle::clean() { if ( mTempRubberBand ) { delete mTempRubberBand; mTempRubberBand = nullptr; } mPoints.clear(); if ( mParentTool ) { mParentTool->deleteTempRubberBand(); } mCircle = QgsCircle(); QgsVectorLayer *vLayer = static_cast<QgsVectorLayer *>( QgisApp::instance()->activeLayer() ); if ( vLayer ) mLayerType = vLayer->geometryType(); }
void QgsMapCanvas::updateDatumTransformEntries() { if ( !mSettings.hasCrsTransformEnabled() ) return; QString destAuthId = mSettings.destinationCrs().authid(); Q_FOREACH ( const QString& layerID, mSettings.layers() ) { QgsMapLayer* layer = QgsMapLayerRegistry::instance()->mapLayer( layerID ); if ( !layer ) continue; QgsVectorLayer *vl = qobject_cast<QgsVectorLayer *>( layer ); if ( vl && vl->geometryType() == QGis::NoGeometry ) continue; // if there are more options, ask the user which datum transform to use if ( !mSettings.datumTransformStore().hasEntryForLayer( layer ) ) getDatumTransformInfo( layer, layer->crs().authid(), destAuthId ); } }