void QgsSymbolLevelsV2Dialog::populateTable()
{
for ( int row = 0; row < mList.count(); row++ )
{
QgsSymbolV2* sym = mList[row].second;
QString label = mList[row].first;
QTableWidgetItem *itemLabel = new QTableWidgetItem( label );
itemLabel->setFlags( itemLabel->flags() ^ Qt::ItemIsEditable );
tableLevels->setItem( row, 0, itemLabel );
for ( int layer = 0; layer < mMaxLayers; layer++ )
{
QTableWidgetItem* item;
if ( layer >= sym->symbolLayerCount() )
{
item = new QTableWidgetItem();
item->setFlags( Qt::ItemFlags() );
}
else
{
QgsSymbolLayerV2* sl = sym->symbolLayer( layer );
QIcon icon = QgsSymbolLayerV2Utils::symbolLayerPreviewIcon( sl, QgsSymbolV2::MM, QSize( 16, 16 ) );
item = new QTableWidgetItem( icon, QString::number( sl->renderingPass() ) );
}
tableLevels->setItem( row, layer + 1, item );
tableLevels->resizeColumnToContents( 0 );
}
}
}
void QgsSymbolLevelsV2Dialog::renderingPassChanged( int row, int column )
{
if ( row < 0 || row >= mList.count() )
return;
QgsSymbolV2* sym = mList[row].second;
if ( column < 0 || column >= sym->symbolLayerCount() )
return;
sym->symbolLayer( column )->setRenderingPass( tableLevels->item( row, column )->text().toInt() );
}
QgsSymbolLevelsV2Dialog::QgsSymbolLevelsV2Dialog( QgsLegendSymbolList list, bool usingSymbolLevels, QWidget* parent )
: QDialog( parent ), mList( list ), mForceOrderingEnabled( false )
{
setupUi( this );
QSettings settings;
restoreGeometry( settings.value( "/Windows/symbolLevelsDlg/geometry" ).toByteArray() );
tableLevels->setItemDelegate( new SpinBoxDelegate( this ) );
chkEnable->setChecked( usingSymbolLevels );
connect( chkEnable, SIGNAL( clicked() ), this, SLOT( updateUi() ) );
if ( mList.count() > 0 && !mList[0].second )
{
// remove symbolless entry (probably classifier of categorized renderer)
mList.removeFirst();
}
int maxLayers = 0;
tableLevels->setRowCount( mList.count() );
for ( int i = 0; i < mList.count(); i++ )
{
QgsSymbolV2* sym = mList[i].second;
// set icons for the rows
QIcon icon = QgsSymbolLayerV2Utils::symbolPreviewIcon( sym, QSize( 16, 16 ) );
tableLevels->setVerticalHeaderItem( i, new QTableWidgetItem( icon, QString() ) );
// find out max. number of layers per symbol
int layers = sym->symbolLayerCount();
if ( layers > maxLayers )
maxLayers = layers;
}
tableLevels->setColumnCount( maxLayers + 1 );
tableLevels->setHorizontalHeaderItem( 0, new QTableWidgetItem( QString() ) );
for ( int i = 0; i < maxLayers; i++ )
{
QString name = tr( "Layer %1" ).arg( i );
tableLevels->setHorizontalHeaderItem( i + 1, new QTableWidgetItem( name ) );
}
mMaxLayers = maxLayers;
updateUi();
if ( !usingSymbolLevels )
setDefaultLevels();
populateTable();
connect( tableLevels, SIGNAL( cellChanged( int, int ) ), this, SLOT( renderingPassChanged( int, int ) ) );
}
void QgsSymbolLevelsV2Dialog::setDefaultLevels()
{
for ( int i = 0; i < mList.count(); i++ )
{
QgsSymbolV2* sym = mList[i].second;
for ( int layer = 0; layer < sym->symbolLayerCount(); layer++ )
{
sym->symbolLayer( layer )->setRenderingPass( layer );
}
}
}
void QgsSymbolV2SelectorDialog::setSymbolFromStyle( const QModelIndex & index )
{
QString symbolName = index.data( Qt::UserRole ).toString();
lblSymbolName->setText( symbolName );
// get new instance of symbol from style
QgsSymbolV2* s = mStyle->symbol( symbolName );
// remove all symbol layers from original symbol
while ( mSymbol->symbolLayerCount() )
mSymbol->deleteSymbolLayer( 0 );
// move all symbol layers to our symbol
while ( s->symbolLayerCount() )
{
QgsSymbolLayerV2* sl = s->takeSymbolLayer( 0 );
mSymbol->appendSymbolLayer( sl );
}
// delete the temporary symbol
delete s;
updateSymbolPreview();
updateSymbolInfo();
emit symbolModified();
}
void QgsSymbolLevelsV2Dialog::populateTable()
{
for ( int row = 0; row < mList.count(); row++ )
{
QgsSymbolV2* sym = mList[row].second;
for ( int layer = 0; layer < mMaxLayers; layer++ )
{
QTableWidgetItem* item;
if ( layer >= sym->symbolLayerCount() )
{
item = new QTableWidgetItem();
item->setFlags( Qt::ItemFlags() );
}
else
{
QgsSymbolLayerV2* sl = sym->symbolLayer( layer );
QIcon icon = QgsSymbolLayerV2Utils::symbolLayerPreviewIcon( sl, QgsSymbolV2::MM, QSize( 16, 16 ) );
item = new QTableWidgetItem( icon, QString::number( sl->renderingPass() ) );
}
tableLevels->setItem( row, layer, item );
}
}
}
void QgsVectorLayerRenderer::drawRendererV2Levels( QgsFeatureIterator& fit )
{
QHash< QgsSymbolV2*, QList<QgsFeature> > features; // key = symbol, value = array of features
QgsSingleSymbolRendererV2* selRenderer = nullptr;
if ( !mSelectedFeatureIds.isEmpty() )
{
selRenderer = new QgsSingleSymbolRendererV2( QgsSymbolV2::defaultSymbol( mGeometryType ) );
selRenderer->symbol()->setColor( mContext.selectionColor() );
selRenderer->setVertexMarkerAppearance( mVertexMarkerStyle, mVertexMarkerSize );
selRenderer->startRender( mContext, mFields );
}
QgsExpressionContextScope* symbolScope = QgsExpressionContextUtils::updateSymbolScope( nullptr );
mContext.expressionContext().appendScope( symbolScope );
// 1. fetch features
QgsFeature fet;
while ( fit.nextFeature( fet ) )
{
if ( !fet.constGeometry() )
continue; // skip features without geometry
if ( mContext.renderingStopped() )
{
qDebug( "rendering stop!" );
stopRendererV2( selRenderer );
mContext.expressionContext().popScope();
return;
}
mContext.expressionContext().setFeature( fet );
QgsSymbolV2* sym = mRendererV2->symbolForFeature( fet, mContext );
if ( !sym )
{
continue;
}
if ( !features.contains( sym ) )
{
features.insert( sym, QList<QgsFeature>() );
}
features[sym].append( fet );
if ( mCache )
{
// Cache this for the use of (e.g.) modifying the feature's uncommitted geometry.
mCache->cacheGeometry( fet.id(), *fet.constGeometry() );
}
if ( mContext.labelingEngine() )
{
mContext.expressionContext().setFeature( fet );
if ( mLabeling )
{
mContext.labelingEngine()->registerFeature( mLayerID, fet, mContext );
}
if ( mDiagrams )
{
mContext.labelingEngine()->registerDiagramFeature( mLayerID, fet, mContext );
}
}
// new labeling engine
if ( mContext.labelingEngineV2() )
{
QScopedPointer<QgsGeometry> obstacleGeometry;
QgsSymbolV2List symbols = mRendererV2->originalSymbolsForFeature( fet, mContext );
if ( !symbols.isEmpty() && fet.constGeometry()->type() == QGis::Point )
{
obstacleGeometry.reset( QgsVectorLayerLabelProvider::getPointObstacleGeometry( fet, mContext, symbols ) );
}
if ( !symbols.isEmpty() )
{
QgsExpressionContextUtils::updateSymbolScope( symbols.at( 0 ), symbolScope );
}
if ( mLabelProvider )
{
mLabelProvider->registerFeature( fet, mContext, obstacleGeometry.data() );
}
if ( mDiagramProvider )
{
mDiagramProvider->registerFeature( fet, mContext, obstacleGeometry.data() );
}
}
}
mContext.expressionContext().popScope();
// find out the order
QgsSymbolV2LevelOrder levels;
QgsSymbolV2List symbols = mRendererV2->symbols( mContext );
for ( int i = 0; i < symbols.count(); i++ )
{
QgsSymbolV2* sym = symbols[i];
for ( int j = 0; j < sym->symbolLayerCount(); j++ )
{
int level = sym->symbolLayer( j )->renderingPass();
if ( level < 0 || level >= 1000 ) // ignore invalid levels
continue;
QgsSymbolV2LevelItem item( sym, j );
while ( level >= levels.count() ) // append new empty levels
levels.append( QgsSymbolV2Level() );
levels[level].append( item );
}
}
// 2. draw features in correct order
for ( int l = 0; l < levels.count(); l++ )
{
QgsSymbolV2Level& level = levels[l];
for ( int i = 0; i < level.count(); i++ )
{
QgsSymbolV2LevelItem& item = level[i];
if ( !features.contains( item.symbol() ) )
{
QgsDebugMsg( "level item's symbol not found!" );
continue;
}
int layer = item.layer();
QList<QgsFeature>& lst = features[item.symbol()];
QList<QgsFeature>::iterator fit;
for ( fit = lst.begin(); fit != lst.end(); ++fit )
{
if ( mContext.renderingStopped() )
{
stopRendererV2( selRenderer );
return;
}
bool sel = mSelectedFeatureIds.contains( fit->id() );
// maybe vertex markers should be drawn only during the last pass...
bool drawMarker = ( mDrawVertexMarkers && mContext.drawEditingInformation() && ( !mVertexMarkerOnlyForSelection || sel ) );
mContext.expressionContext().setFeature( *fit );
try
{
mRendererV2->renderFeature( *fit, mContext, layer, sel, drawMarker );
}
catch ( const QgsCsException &cse )
{
Q_UNUSED( cse );
QgsDebugMsg( QString( "Failed to transform a point while drawing a feature with ID '%1'. Ignoring this feature. %2" )
.arg( fet.id() ).arg( cse.what() ) );
}
}
}
}
stopRendererV2( selRenderer );
}
void QgsDxfExport::writeEntitiesSymbolLevels( QgsVectorLayer* layer )
{
if ( !layer )
{
return;
}
QgsFeatureRendererV2* renderer = layer->rendererV2();
if ( !renderer )
{
//return error
}
QHash< QgsSymbolV2*, QList<QgsFeature> > features;
QgsRenderContext ctx = renderContext();
QgsSymbolV2RenderContext sctx( ctx, QgsSymbolV2::MM , 1.0, false, 0, 0 );
renderer->startRender( ctx, layer->pendingFields() );
//get iterator
QgsFeatureRequest req;
if ( layer->wkbType() == QGis::WKBNoGeometry )
{
req.setFlags( QgsFeatureRequest::NoGeometry );
}
req.setSubsetOfAttributes( QStringList( renderer->usedAttributes() ), layer->pendingFields() );
if ( !mExtent.isEmpty() )
{
req.setFilterRect( mExtent );
}
QgsFeatureIterator fit = layer->getFeatures( req );
//fetch features
QgsFeature fet;
QgsSymbolV2* featureSymbol = 0;
while ( fit.nextFeature( fet ) )
{
featureSymbol = renderer->symbolForFeature( fet );
if ( !featureSymbol )
{
continue;
}
QHash< QgsSymbolV2*, QList<QgsFeature> >::iterator it = features.find( featureSymbol );
if ( it == features.end() )
{
it = features.insert( featureSymbol, QList<QgsFeature>() );
}
it.value().append( fet );
}
//find out order
QgsSymbolV2LevelOrder levels;
QgsSymbolV2List symbols = renderer->symbols();
for ( int i = 0; i < symbols.count(); i++ )
{
QgsSymbolV2* sym = symbols[i];
for ( int j = 0; j < sym->symbolLayerCount(); j++ )
{
int level = sym->symbolLayer( j )->renderingPass();
if ( level < 0 || level >= 1000 ) // ignore invalid levels
continue;
QgsSymbolV2LevelItem item( sym, j );
while ( level >= levels.count() ) // append new empty levels
levels.append( QgsSymbolV2Level() );
levels[level].append( item );
}
}
//export symbol layers and symbology
for ( int l = 0; l < levels.count(); l++ )
{
QgsSymbolV2Level& level = levels[l];
for ( int i = 0; i < level.count(); i++ )
{
QgsSymbolV2LevelItem& item = level[i];
QHash< QgsSymbolV2*, QList<QgsFeature> >::iterator levelIt = features.find( item.symbol() );
int llayer = item.layer();
QList<QgsFeature>& featureList = levelIt.value();
QList<QgsFeature>::iterator featureIt = featureList.begin();
for ( ; featureIt != featureList.end(); ++featureIt )
{
addFeature( sctx, layer->name(), levelIt.key()->symbolLayer( llayer ), levelIt.key() );
}
}
}
renderer->stopRender( ctx );
}
void QgsDxfExport::writeEntities()
{
startSection();
writeGroup( 2, "ENTITIES" );
//label engine
QgsDxfPalLabeling labelEngine( this, mExtent.isEmpty() ? dxfExtent() : mExtent, mSymbologyScaleDenominator, mMapUnits );
QgsRenderContext& ctx = labelEngine.renderContext();
//iterate through the maplayers
QList< QgsMapLayer* >::iterator layerIt = mLayers.begin();
for ( ; layerIt != mLayers.end(); ++layerIt )
{
QgsVectorLayer* vl = qobject_cast<QgsVectorLayer*>( *layerIt );
if ( !vl || !layerIsScaleBasedVisible( vl ) )
{
continue;
}
QgsSymbolV2RenderContext sctx( ctx, QgsSymbolV2::MM , 1.0, false, 0, 0 );
QgsFeatureRendererV2* renderer = vl->rendererV2();
renderer->startRender( ctx, vl->pendingFields() );
QStringList attributes = renderer->usedAttributes();
bool labelLayer = ( labelEngine.prepareLayer( vl, attributes, ctx ) != 0 );
if ( mSymbologyExport == QgsDxfExport::SymbolLayerSymbology && ( renderer->capabilities() & QgsFeatureRendererV2::SymbolLevels ) &&
renderer->usingSymbolLevels() )
{
writeEntitiesSymbolLevels( vl );
renderer->stopRender( ctx );
continue;
}
QgsFeatureRequest freq = QgsFeatureRequest().setSubsetOfAttributes(
attributes, vl->pendingFields() );
if ( !mExtent.isEmpty() )
{
freq.setFilterRect( mExtent );
}
QgsFeatureIterator featureIt = vl->getFeatures( freq );
QgsFeature fet;
while ( featureIt.nextFeature( fet ) )
{
sctx.setFeature( &fet );
if ( mSymbologyExport == NoSymbology )
{
addFeature( sctx, dxfLayerName( vl->name() ), 0, 0 ); //no symbology at all
}
else
{
if ( !renderer )
{
continue;
}
QgsSymbolV2List symbolList = renderer->symbolsForFeature( fet );
if ( symbolList.size() < 1 )
{
continue;
}
if ( mSymbologyExport == QgsDxfExport::SymbolLayerSymbology ) //symbol layer symbology, but layer does not use symbol levels
{
QgsSymbolV2List::iterator symbolIt = symbolList.begin();
for ( ; symbolIt != symbolList.end(); ++symbolIt )
{
int nSymbolLayers = ( *symbolIt )->symbolLayerCount();
for ( int i = 0; i < nSymbolLayers; ++i )
{
addFeature( sctx, dxfLayerName( vl->name() ), ( *symbolIt )->symbolLayer( i ), *symbolIt );
}
}
}
else
{
//take first symbollayer from first symbol
QgsSymbolV2* s = symbolList.first();
if ( !s || s->symbolLayerCount() < 1 )
{
continue;
}
addFeature( sctx, dxfLayerName( vl->name() ), s->symbolLayer( 0 ), s );
}
if ( labelLayer )
{
labelEngine.registerFeature( vl->id(), fet, ctx );
}
}
}
renderer->stopRender( ctx );
}
labelEngine.drawLabeling( ctx );
endSection();
}