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 );
}
}