sharpetronics/QGIS
1
0
Fork 0
mirror of https://github.com/qgis/QGIS.git synced 2025-04-16 00:03:12 -04:00
Code Issues Packages Projects Releases Wiki Activity

[API] Removed old renderer support from QgsVectorLayer

Browse Source
This commit is contained in:
Martin Dobias 2013-04-07 19:48:03 +02:00
parent 37da713c7e
commit c2f00caedf
25 changed files with 358 additions and 1592 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
python/core/core.sip
View File

@ -171,7 +171,6 @@
%Include symbology-ng/qgsstylev2.sip
%Include symbology-ng/qgssvgcache.sip
%Include symbology-ng/qgssymbologyv2conversion.sip
%Include symbology-ng/qgssymbolv2.sip
%Include symbology-ng/qgscolorbrewerpalette.sip
%Include symbology-ng/qgscptcityarchive.sip

14
python/core/qgsvectorlayer.sip
View File

@ -242,12 +242,6 @@ class QgsVectorLayer : QgsMapLayer
/** Returns the bounding box of the selected features. If there is no selection, QgsRectangle(0,0,0,0) is returned */
QgsRectangle boundingBoxOfSelected();
/** Returns a pointer to the renderer */
const QgsRenderer* renderer() const;
/** Sets the renderer. If a renderer is already present, it is deleted */
void setRenderer( QgsRenderer * r /Transfer/ );
/** Sets diagram rendering object (takes ownership) */
void setDiagramRenderer( QgsDiagramRendererV2* r /Transfer/ );
const QgsDiagramRendererV2* diagramRenderer() const;
@ -262,14 +256,6 @@ class QgsVectorLayer : QgsMapLayer
* @note added in 1.4
*/
void setRendererV2( QgsFeatureRendererV2* r /Transfer/ );
/** Return whether using renderer V2.
* @note added in 1.4
*/
bool isUsingRendererV2();
/** set whether to use renderer V2 for drawing.
* @note added in 1.4
*/
void setUsingRendererV2( bool usingRendererV2 );
/** Draw layer with renderer V2.
* @note added in 1.4

24
python/core/symbology-ng/qgssymbologyv2conversion.sip
View File

@ -1,24 +0,0 @@
class QgsSymbologyV2Conversion
{
%TypeHeaderCode
#include <qgssymbologyv2conversion.h>
%End
public:
//! return a symbol in new symbology as close as possible to old symbol
//! @note not all properties will be preserved
static QgsSymbolV2* symbolV1toV2( const QgsSymbol* s ) /Factory/;
//! return a symbol in old symbology as close as possible to new symbol
//! @note not all properties will be preserved
static QgsSymbol* symbolV2toV1( QgsSymbolV2* s ) /Factory/;
//! convert layer from old symbology to new symbology
//! @note not all properties will be preserved
static void rendererV1toV2( QgsVectorLayer* layer );
//! convert layer from new symbology to old symbology
//! @note not all properties will be preserved
static void rendererV2toV1( QgsVectorLayer* layer );
};

157
src/app/legend/qgslegendlayer.cpp
View File

@ -137,10 +137,7 @@ void QgsLegendLayer::refreshSymbology( const QString& key, double widthScale )
if ( theMapLayer->type() == QgsMapLayer::VectorLayer ) // VECTOR
{
QgsVectorLayer* vlayer = qobject_cast<QgsVectorLayer *>( theMapLayer );
if ( vlayer->isUsingRendererV2() )
vectorLayerSymbologyV2( vlayer );
else
vectorLayerSymbology( vlayer, widthScale ); // get and change symbology
}
else if ( theMapLayer->type() == QgsMapLayer::RasterLayer ) // RASTER
{
@ -187,106 +184,6 @@ void QgsLegendLayer::changeSymbologySettings( const QgsMapLayer* theMapLayer,
void QgsLegendLayer::vectorLayerSymbology( QgsVectorLayer* layer, double widthScale )
{
if ( !layer )
{
return;
}
SymbologyList itemList;
if ( layer->hasGeometryType() )
{
//add the new items
QString lw, uv, label;
const QgsRenderer* renderer = layer->renderer();
const QList<QgsSymbol*> sym = renderer->symbols();
//create an item for each classification field (only one for most renderers)
QSettings settings;
if ( settings.value( "/qgis/showLegendClassifiers", false ).toBool() )
{
if ( renderer->needsAttributes() )
{
QgsAttributeList classfieldlist = renderer->classificationAttributes();
const QgsFields& fields = layer->pendingFields();
for ( QgsAttributeList::iterator it = classfieldlist.begin(); it != classfieldlist.end(); ++it )
{
int idx = *it;
if ( idx < 0 || idx >= fields.count() )
continue;
QString classfieldname = layer->attributeAlias( idx );
if ( classfieldname.isEmpty() )
{
classfieldname = fields[idx].name();
}
itemList.append( qMakePair( classfieldname, QPixmap() ) );
}
}
}
QMap< QgsSymbol*, int > featureCountMap;
if ( mShowFeatureCount )
{
updateItemListCount( layer, sym, featureCountMap );
}
for ( QList<QgsSymbol*>::const_iterator it = sym.begin(); it != sym.end(); ++it )
{
QImage img;
if (( *it )->type() == QGis::Point )
{
img = ( *it )->getPointSymbolAsImage( widthScale );
}
else if (( *it )->type() == QGis::Line )
{
img = ( *it )->getLineSymbolAsImage();
}
else if (( *it )->type() == QGis::Polygon )
{
img = ( *it )->getPolygonSymbolAsImage();
}
else
{
// must be a layer without geometry then
}
QString values;
lw = ( *it )->lowerValue();
if ( !lw.isEmpty() )
{
values += lw;
}
uv = ( *it )->upperValue();
if ( !uv.isEmpty() && lw != uv )
{
values += " - ";
values += uv;
}
label = ( *it )->label();
if ( !label.isEmpty() )
{
values += " ";
values += label;
}
if ( mShowFeatureCount )
{
int fCount = featureCountMap[*it];
if ( fCount >= 0 )
{
values += ( " [" + QString::number( fCount ) + "]" );
}
}
QPixmap pix = QPixmap::fromImage( img ); // convert to pixmap
itemList.append( qMakePair( values, pix ) );
}
}
changeSymbologySettings( layer, itemList );
}
void QgsLegendLayer::vectorLayerSymbologyV2( QgsVectorLayer* layer )
{
QSize iconSize( 16, 16 );
@ -666,60 +563,6 @@ void QgsLegendLayer::updateItemListCountV2( SymbologyList& itemList, QgsVectorLa
}
}
void QgsLegendLayer::updateItemListCount( QgsVectorLayer* layer, const QList<QgsSymbol*>& sym, QMap< QgsSymbol*, int >& featureCountMap )
{
featureCountMap.clear();
QList<QgsSymbol*>::const_iterator symbolIt = sym.constBegin();
for ( ; symbolIt != sym.constEnd(); ++symbolIt )
{
featureCountMap.insert( *symbolIt, 0 );
}
QgsRenderer* renderer = const_cast<QgsRenderer*>( layer->renderer() );
if ( !renderer )
{
return;
}
//go through all features and count the number of occurrences
int nFeatures = layer->pendingFeatureCount();
QProgressDialog p( tr( "Updating feature count for layer %1" ).arg( layer->name() ), tr( "Abort" ), 0, nFeatures );
p.setWindowModality( Qt::WindowModal );
int featuresCounted = 0;
QgsFeatureIterator fit = layer->getFeatures( QgsFeatureRequest().setFlags( QgsFeatureRequest::NoGeometry ) );
QgsFeature f;
QgsSymbol* currentSymbol = 0;
while ( fit.nextFeature( f ) )
{
currentSymbol = renderer->symbolForFeature( &f );
if ( currentSymbol )
{
featureCountMap[currentSymbol] += 1;
}
++featuresCounted;
if ( featuresCounted % 50 == 0 )
{
if ( featuresCounted > nFeatures ) //sometimes the feature count is not correct
{
p.setMaximum( 0 );
}
p.setValue( featuresCounted );
if ( p.wasCanceled() ) //set all entries to -1 (= invalid)
{
QMap< QgsSymbol*, int >::iterator cIt = featureCountMap.begin();
for ( ; cIt != featureCountMap.end(); ++cIt )
{
cIt.value() = -1;
}
return;
}
}
}
p.setValue( nFeatures );
}
void QgsLegendLayer::setShowFeatureCount( bool show, bool update )
{

4
src/app/legend/qgslegendlayer.h
View File

@ -110,8 +110,6 @@ class QgsLegendLayer : public QgsLegendItem
protected:
/** Prepare and change symbology for vector layer */
void vectorLayerSymbology( QgsVectorLayer* mapLayer, double widthScale = 1.0 );
void vectorLayerSymbologyV2( QgsVectorLayer* vlayer );
/** Prepare and change symbology for raster layer */
@ -122,8 +120,6 @@ class QgsLegendLayer : public QgsLegendItem
/**Adds feature counts to the symbology items (for symbology v2)*/
void updateItemListCountV2( SymbologyList& itemList, QgsVectorLayer* layer );
/**Calculates feature count for the individual symbols (old symbology)*/
void updateItemListCount( QgsVectorLayer* layer, const QList<QgsSymbol*>& sym, QMap< QgsSymbol*, int >& featureCountMap );
QPixmap getOriginalPixmap();

44
src/app/qgsmaptoolrotatepointsymbols.cpp
View File

@ -238,26 +238,6 @@ int QgsMapToolRotatePointSymbols::layerRotationAttributes( QgsVectorLayer* vl, Q
return 1;
}
//old symbology
const QgsRenderer* layerRenderer = vl->renderer();
if ( layerRenderer )
{
//get renderer symbols
const QList<QgsSymbol*> rendererSymbols = layerRenderer->symbols();
int currentRotationAttribute;
QList<QgsSymbol*>::const_iterator symbolIt = rendererSymbols.constBegin();
for ( ; symbolIt != rendererSymbols.constEnd(); ++symbolIt )
{
currentRotationAttribute = ( *symbolIt )->rotationClassificationField();
if ( currentRotationAttribute >= 0 )
{
attList.push_back( currentRotationAttribute );
}
}
return 0;
}
//new symbology
const QgsFeatureRendererV2* symbologyNgRenderer = vl->rendererV2();
if ( symbologyNgRenderer )
@ -306,27 +286,10 @@ void QgsMapToolRotatePointSymbols::createPixmapItem( QgsFeature& f )
//get the image that is used for that symbol, but without point rotation
QImage pointImage;
QgsRenderer* r = 0;
QgsFeatureRendererV2* rv2 = 0;
if ( mActiveLayer && mActiveLayer->renderer() ) //old symbology
if ( mActiveLayer && mActiveLayer->rendererV2() ) //symbology-ng
{
//copy renderer
QgsRenderer* r = mActiveLayer->renderer()->clone();
//set all symbol fields of the cloned renderer to -1. Very ugly but necessary
QList<QgsSymbol*> symbolList( r->symbols() );
QList<QgsSymbol*>::iterator it = symbolList.begin();
for ( ; it != symbolList.end(); ++it )
{
( *it )->setRotationClassificationField( -1 );
}
r->renderFeature( *renderContext, f, &pointImage, false );
}
else if ( mActiveLayer && mActiveLayer->rendererV2() ) //symbology-ng
{
rv2 = mActiveLayer->rendererV2()->clone();
QgsFeatureRendererV2* rv2 = mActiveLayer->rendererV2()->clone();
rv2->setRotationField( "" );
rv2->startRender( *renderContext, mActiveLayer );
@ -336,12 +299,11 @@ void QgsMapToolRotatePointSymbols::createPixmapItem( QgsFeature& f )
pointImage = symbolV2->bigSymbolPreviewImage();
}
rv2->stopRender( *renderContext );
delete rv2;
}
mRotationItem = new QgsPointRotationItem( mCanvas );
mRotationItem->setSymbol( pointImage );
delete r;
delete rv2;
}
void QgsMapToolRotatePointSymbols::setPixmapItemRotation( double rotation )

10
src/app/qgsoptions.cpp
View File

@ -500,15 +500,6 @@ QgsOptions::QgsOptions( QWidget *parent, Qt::WFlags fl ) :
chkAntiAliasing->setChecked( settings.value( "/qgis/enable_anti_aliasing", true ).toBool() );
chkUseRenderCaching->setChecked( settings.value( "/qgis/enable_render_caching", false ).toBool() );
//Changed to default to true as of QGIS 1.7
//TODO: remove hack when http://hub.qgis.org/issues/5170 is fixed
#ifdef ANDROID
bool use_symbology_ng_default = false;
#else
bool use_symbology_ng_default = true;
#endif
chkUseSymbologyNG->setChecked( settings.value( "/qgis/use_symbology_ng", use_symbology_ng_default ).toBool() );
// Slightly awkard here at the settings value is true to use QImage,
// but the checkbox is true to use QPixmap
chkUseQPixmap->setChecked( !( settings.value( "/qgis/use_qimage_to_render", true ).toBool() ) );
@ -1031,7 +1022,6 @@ void QgsOptions::saveOptions()
settings.setValue( "/qgis/enable_anti_aliasing", chkAntiAliasing->isChecked() );
settings.setValue( "/qgis/enable_render_caching", chkUseRenderCaching->isChecked() );
settings.setValue( "/qgis/use_qimage_to_render", !( chkUseQPixmap->isChecked() ) );
settings.setValue( "/qgis/use_symbology_ng", chkUseSymbologyNG->isChecked() );
settings.setValue( "/qgis/legendDoubleClickAction", cmbLegendDoubleClickAction->currentIndex() );
bool legendLayersCapitalise = settings.value( "/qgis/capitaliseLayerName", false ).toBool();
settings.setValue( "/qgis/capitaliseLayerName", capitaliseCheckBox->isChecked() );

13
src/app/qgsvectorlayerproperties.cpp
View File

@ -413,12 +413,8 @@ void QgsVectorLayerProperties::apply()
// Apply fields settings
mFieldsPropertiesDialog->apply();
if ( layer->isUsingRendererV2() )
{
QgsRendererV2PropertiesDialog* dlg =
static_cast<QgsRendererV2PropertiesDialog*>( widgetStackRenderers->currentWidget() );
QgsRendererV2PropertiesDialog* dlg = static_cast<QgsRendererV2PropertiesDialog*>( widgetStackRenderers->currentWidget() );
dlg->apply();
}
//apply diagram settings
diagramPropertiesDialog->apply();
@ -778,19 +774,12 @@ void QgsVectorLayerProperties::updateSymbologyPage()
delete mRendererDialog;
mRendererDialog = 0;
if ( layer->isUsingRendererV2() )
{
mRendererDialog = new QgsRendererV2PropertiesDialog( layer, QgsStyleV2::defaultStyle(), true );
// display the menu to choose the output format (fix #5136)
pbnSaveStyleAs->setText( tr( "Save Style" ) );
pbnSaveStyleAs->setMenu( mSaveAsMenu );
QObject::disconnect( pbnSaveStyleAs, SIGNAL( clicked() ), this, SLOT( on_pbnSaveStyleAs_clicked() ) );
}
else
{
tabWidget->setTabEnabled( 0, false ); // hide symbology item
}
if ( mRendererDialog )
{

71
src/core/composer/qgslegendmodel.cpp
View File

@ -190,64 +190,7 @@ int QgsLegendModel::addVectorLayerItemsV2( QStandardItem* layerItem, QgsVectorLa
return 0;
}
int QgsLegendModel::addVectorLayerItems( QStandardItem* layerItem, QgsVectorLayer* vlayer )
{
if ( !layerItem || !vlayer )
{
return 1;
}
int opacity = vlayer->getTransparency();
const QgsRenderer* vectorRenderer = vlayer->renderer();
if ( !vectorRenderer )
{
return 3;
}
//text field that describes classification attribute?
QSettings settings;
if ( settings.value( "/qgis/showLegendClassifiers", false ).toBool() )
{
const QgsFields& layerFields = vlayer->pendingFields();
QgsAttributeList attributes = vectorRenderer->classificationAttributes();
QgsAttributeList::const_iterator att_it = attributes.constBegin();
for ( ; att_it != attributes.constEnd(); ++att_it )
{
int idx = *att_it;
if ( idx >= 0 && idx < layerFields.count() )
{
QString attributeName = vlayer->attributeDisplayName( idx );
QStandardItem* attributeItem = new QStandardItem( attributeName );
attributeItem->setData( QgsLegendModel::ClassificationItem, Qt::UserRole + 1 ); //first user data stores the item type
attributeItem->setFlags( Qt::ItemIsEnabled | Qt::ItemIsSelectable );
layerItem->setChild( layerItem->rowCount(), 0, attributeItem );
}
}
}
const QList<QgsSymbol*> vectorSymbols = vectorRenderer->symbols();
QList<QgsSymbol*>::const_iterator symbolIt = vectorSymbols.constBegin();
for ( ; symbolIt != vectorSymbols.constEnd(); ++symbolIt )
{
if ( !( *symbolIt ) )
{
continue;
}
QStandardItem* currentSymbolItem = itemFromSymbol( *symbolIt, opacity, vlayer->id() );
if ( !currentSymbolItem )
{
continue;
}
layerItem->setChild( layerItem->rowCount(), 0, currentSymbolItem );
}
return 0;
}
int QgsLegendModel::addRasterLayerItems( QStandardItem* layerItem, QgsMapLayer* rlayer )
{
@ -330,16 +273,9 @@ void QgsLegendModel::updateLayer( QStandardItem* layerItem )
layerItem->setText( label );
if ( vLayer )
{
if ( vLayer->isUsingRendererV2() )
{
addVectorLayerItemsV2( lItem, vLayer );
}
else
{
addVectorLayerItems( lItem, vLayer );
}
}
QgsRasterLayer* rLayer = qobject_cast<QgsRasterLayer*>( mapLayer );
if ( rLayer )
@ -392,16 +328,9 @@ void QgsLegendModel::addLayer( QgsMapLayer* theMapLayer )
{
QgsVectorLayer* vl = dynamic_cast<QgsVectorLayer*>( theMapLayer );
if ( vl )
{
if ( vl->isUsingRendererV2() )
{
addVectorLayerItemsV2( layerItem, vl );
}
else
{
addVectorLayerItems( layerItem, vl );
}
}
break;
}
case QgsMapLayer::RasterLayer:

4
src/core/composer/qgslegendmodel.h
View File

@ -102,10 +102,6 @@ class CORE_EXPORT QgsLegendModel: public QStandardItemModel
void layersChanged();
private:
/**Adds classification items of vector layers
@return 0 in case of success*/
int addVectorLayerItems( QStandardItem* layerItem, QgsVectorLayer* vlayer );
/**Adds classification items of vector layers using new symbology*/
int addVectorLayerItemsV2( QStandardItem* layerItem, QgsVectorLayer* vlayer );

6
src/core/qgsproject.cpp
View File

@ -702,17 +702,11 @@ QPair< bool, QList<QDomNode> > QgsProject::_getMapLayers( QDomDocument const &do
//Update field map of layers with joins and create join caches if necessary
//Needs to be done here once all dependent layers are loaded
QString errorMessage;
QList< QPair< QgsVectorLayer*, QDomElement > >::iterator vIt = vLayerList.begin();
for ( ; vIt != vLayerList.end(); ++vIt )
{
vIt->first->createJoinCaches();
vIt->first->updateFields();
//for old symbology, it is necessary to read the symbology again after having the complete field map
if ( !vIt->first->isUsingRendererV2() )
{
vIt->first->readSymbology( vIt->second, errorMessage );
}
}
return qMakePair( returnStatus, brokenNodes );

11
src/core/qgsvectorfilewriter.cpp
View File

@ -770,7 +770,7 @@ QgsVectorFileWriter::writeAsVectorFormat( QgsVectorLayer* layer,
//writer->createSymbolLayerTable( layer, writer->mDS );
}
if ( writer->symbologyExport() == SymbolLayerSymbology && layer->isUsingRendererV2() )
if ( writer->symbologyExport() == SymbolLayerSymbology )
{
QgsFeatureRendererV2* r = layer->rendererV2();
if ( r->capabilities() & QgsFeatureRendererV2::SymbolLevels
@ -1198,11 +1198,6 @@ void QgsVectorFileWriter::createSymbolLayerTable( QgsVectorLayer* vl, const Qgs
return;
}
if ( !vl->isUsingRendererV2() )
{
return;
}
QgsFeatureRendererV2* renderer = vl->rendererV2();
if ( !renderer )
{
@ -1246,7 +1241,7 @@ void QgsVectorFileWriter::createSymbolLayerTable( QgsVectorLayer* vl, const Qgs
QgsVectorFileWriter::WriterError QgsVectorFileWriter::exportFeaturesSymbolLevels( QgsVectorLayer* layer, QgsFeatureIterator& fit,
const QgsCoordinateTransform* ct, QString* errorMessage )
{
if ( !layer || !layer->isUsingRendererV2() )
if ( !layer )
{
//return error
}
@ -1454,7 +1449,7 @@ QgsFeatureRendererV2* QgsVectorFileWriter::symbologyRenderer( QgsVectorLayer* vl
{
return 0;
}
if ( !vl || !vl->isUsingRendererV2() )
if ( !vl )
{
return 0;
}

797
src/core/qgsvectorlayer.cpp
View File

@ -77,6 +77,7 @@
#include "qgssinglesymbolrendererv2.h"
#include "qgsdiagramrendererv2.h"
#include "qgsstylev2.h"
#include "qgssymbologyv2conversion.h"
#ifdef TESTPROVIDERLIB
#include <dlfcn.h>
@ -94,9 +95,7 @@ QgsVectorLayer::QgsVectorLayer( QString vectorLayerPath,
, mDataProvider( NULL )
, mProviderKey( providerKey )
, mReadOnly( false )
, mRenderer( 0 )
, mRendererV2( NULL )
, mUsingRendererV2( false )
, mLabel( 0 )
, mLabelOn( false )
, mVertexMarkerOnlyForSelection( false )
@ -126,20 +125,6 @@ QgsVectorLayer::QgsVectorLayer( QString vectorLayerPath,
updateFields();
QSettings settings;
//Changed to default to true as of QGIS 1.7
//TODO: remove hack when http://hub.qgis.org/issues/5170 is fixed
#ifdef ANDROID
bool use_symbology_ng_default = false;
#else
bool use_symbology_ng_default = true;
#endif
if ( settings.value( "/qgis/use_symbology_ng", use_symbology_ng_default ).toBool() && hasGeometryType() )
{
// using symbology-ng!
setUsingRendererV2( true );
}
// check if there is a default style / propertysheet defined
// for this layer and if so apply it
bool defaultLoadedFlag = false;
@ -152,16 +137,8 @@ QgsVectorLayer::QgsVectorLayer( QString vectorLayerPath,
if ( !defaultLoadedFlag && hasGeometryType() )
{
// add single symbol renderer
if ( mUsingRendererV2 )
{
setRendererV2( QgsFeatureRendererV2::defaultRenderer( geometryType() ) );
}
else
{
QgsSingleSymbolRenderer *renderer = new QgsSingleSymbolRenderer( geometryType() );
setRenderer( renderer );
}
}
connect( QgsMapLayerRegistry::instance(), SIGNAL( layerWillBeRemoved( QString ) ), this, SLOT( checkJoinLayerRemove( QString ) ) );
@ -186,7 +163,6 @@ QgsVectorLayer::~QgsVectorLayer()
mValid = false;
delete mRenderer;
delete mDataProvider;
delete mEditBuffer;
delete mJoinBuffer;
@ -329,18 +305,12 @@ void QgsVectorLayer::drawLabels( QgsRenderContext& rendererContext )
QgsDebugMsg( "Starting draw of labels: " + id() );
if (( mRenderer || mRendererV2 ) && mLabelOn &&
if ( mRendererV2 && mLabelOn &&
( !mLabel->scaleBasedVisibility() ||
( mLabel->minScale() <= rendererContext.rendererScale() &&
rendererContext.rendererScale() <= mLabel->maxScale() ) ) )
{
QgsAttributeList attributes;
if ( mRenderer )
{
attributes = mRenderer->classificationAttributes();
}
else if ( mRendererV2 )
{
foreach ( QString attrName, mRendererV2->usedAttributes() )
{
int attrNum = fieldNameIndex( attrName );
@ -348,7 +318,6 @@ void QgsVectorLayer::drawLabels( QgsRenderContext& rendererContext )
}
// make sure the renderer is ready for classification ("symbolForFeature")
mRendererV2->startRender( rendererContext, this );
}
// Add fields required for labels
mLabel->addRequiredFields( attributes );
@ -368,8 +337,7 @@ void QgsVectorLayer::drawLabels( QgsRenderContext& rendererContext )
QgsFeature fet;
while ( fit.nextFeature( fet ) )
{
if (( mRenderer && mRenderer->willRenderFeature( &fet ) )
|| ( mRendererV2 && mRendererV2->willRenderFeature( fet ) ) )
if ( mRendererV2->willRenderFeature( fet ) )
{
bool sel = mSelectedFeatureIds.contains( fet.id() );
mLabel->renderLabel( rendererContext, fet, sel, 0 );
@ -398,322 +366,6 @@ void QgsVectorLayer::drawLabels( QgsRenderContext& rendererContext )
}
unsigned char *QgsVectorLayer::drawLineString( unsigned char *feature, QgsRenderContext &renderContext )
{
QPainter *p = renderContext.painter();
unsigned char *ptr = feature + 5;
unsigned int wkbType = *(( int* )( feature + 1 ) );
int nPoints = *(( int* )ptr );
ptr = feature + 9;
bool hasZValue = ( wkbType == QGis::WKBLineString25D );
QVector<double> x( nPoints );
QVector<double> y( nPoints );
QVector<double> z( nPoints, 0.0 );
// Extract the points from the WKB format into the x and y vectors.
for ( int i = 0; i < nPoints; ++i )
{
x[i] = *(( double * ) ptr );
ptr += sizeof( double );
y[i] = *(( double * ) ptr );
ptr += sizeof( double );
if ( hasZValue ) // ignore Z value
ptr += sizeof( double );
}
// Transform the points into map coordinates (and reproject if
// necessary)
transformPoints( x, y, z, renderContext );
// Work around a +/- 32768 limitation on coordinates
// Look through the x and y coordinates and see if there are any
// that need trimming. If one is found, there's no need to look at
// the rest of them so end the loop at that point.
for ( int i = 0; i < nPoints; ++i )
{
if ( qAbs( x.at( i ) ) > QgsClipper::MAX_X ||
qAbs( y.at( i ) ) > QgsClipper::MAX_Y )
{
QgsClipper::trimFeature( x, y, true ); // true = polyline
nPoints = x.size(); // trimming may change nPoints.
break;
}
}
// set up QPolygonF class with transformed points
QPolygonF pa( nPoints );
for ( int i = 0; i < nPoints; ++i )
{
pa[i].setX( x.at( i ) );
pa[i].setY( y.at( i ) );
}
// The default pen gives bevelled joins between segements of the
// polyline, which is good enough for the moment.
//preserve a copy of the pen before we start fiddling with it
QPen pen = p->pen(); // to be kept original
//
// experimental alpha transparency
// 255 = opaque
//
QPen myTransparentPen = p->pen(); // store current pen
QColor myColor = myTransparentPen.color();
//only set transparency from layer level if renderer does not provide
//transparency on class level
if ( !mRenderer->usesTransparency() )
{
myColor.setAlpha( mTransparencyLevel );
}
myTransparentPen.setColor( myColor );
p->setPen( myTransparentPen );
p->drawPolyline( pa );
// draw vertex markers if in editing mode, but only to the main canvas
if ( mEditBuffer && renderContext.drawEditingInformation() )
{
QVector<double>::const_iterator xIt;
QVector<double>::const_iterator yIt;
for ( xIt = x.begin(), yIt = y.begin(); xIt != x.end(); ++xIt, ++yIt )
{
drawVertexMarker( *xIt, *yIt, *p, mCurrentVertexMarkerType, mCurrentVertexMarkerSize );
}
}
//restore the pen
p->setPen( pen );
return ptr;
}
unsigned char *QgsVectorLayer::drawPolygon( unsigned char *feature, QgsRenderContext &renderContext )
{
QPainter *p = renderContext.painter();
typedef QPair<QVector<double>, QVector<double> > ringType;
typedef ringType* ringTypePtr;
typedef QVector<ringTypePtr> ringsType;
// get number of rings in the polygon
unsigned int numRings = *(( int* )( feature + 1 + sizeof( int ) ) );
if ( numRings == 0 ) // sanity check for zero rings in polygon
return feature + 9;
unsigned int wkbType = *(( int* )( feature + 1 ) );
bool hasZValue = ( wkbType == QGis::WKBPolygon25D );
int total_points = 0;
// A vector containing a pointer to a pair of double vectors.The
// first vector in the pair contains the x coordinates, and the
// second the y coordinates.
ringsType rings;
// Set pointer to the first ring
unsigned char* ptr = feature + 1 + 2 * sizeof( int );
for ( register unsigned int idx = 0; idx < numRings; idx++ )
{
int nPoints = *(( int* )ptr );
ringTypePtr ring = new ringType( QVector<double>( nPoints ), QVector<double>( nPoints ) );
ptr += 4;
// create a dummy vector for the z coordinate
QVector<double> zVector( nPoints, 0.0 );
// Extract the points from the WKB and store in a pair of
// vectors.
for ( int jdx = 0; jdx < nPoints; jdx++ )
{
ring->first[jdx] = *(( double * ) ptr );
ptr += sizeof( double );
ring->second[jdx] = *(( double * ) ptr );
ptr += sizeof( double );
if ( hasZValue )
ptr += sizeof( double );
}
// If ring has fewer than two points, what is it then?
// Anyway, this check prevents a crash
if ( nPoints < 1 )
{
QgsDebugMsg( "Ring has only " + QString::number( nPoints ) + " points! Skipping this ring." );
continue;
}
transformPoints( ring->first, ring->second, zVector, renderContext );
// Work around a +/- 32768 limitation on coordinates
// Look through the x and y coordinates and see if there are any
// that need trimming. If one is found, there's no need to look at
// the rest of them so end the loop at that point.
for ( int i = 0; i < nPoints; ++i )
{
if ( qAbs( ring->first[i] ) > QgsClipper::MAX_X ||
qAbs( ring->second[i] ) > QgsClipper::MAX_Y )
{
QgsClipper::trimFeature( ring->first, ring->second, false );
break;
}
}
// Don't bother keeping the ring if it has been trimmed out of
// existence.
if ( ring->first.size() == 0 )
delete ring;
else
{
rings.push_back( ring );
total_points += ring->first.size();
}
}
// Now we draw the polygons
// use painter paths for drawing polygons with holes
// when adding polygon to the path they invert the area
// this means that adding inner rings to the path creates
// holes in outer ring
QPainterPath path; // OddEven fill rule by default
// Only try to draw polygons if there is something to draw
if ( total_points > 0 )
{
//preserve a copy of the brush and pen before we start fiddling with it
QBrush brush = p->brush(); //to be kept as original
QPen pen = p->pen(); // to be kept original
//
// experimental alpha transparency
// 255 = opaque
//
QBrush myTransparentBrush = p->brush();
QColor myColor = brush.color();
//only set transparency from layer level if renderer does not provide
//transparency on class level
if ( !mRenderer->usesTransparency() )
{
myColor.setAlpha( mTransparencyLevel );
}
myTransparentBrush.setColor( myColor );
QPen myTransparentPen = p->pen(); // store current pen
myColor = myTransparentPen.color();
//only set transparency from layer level if renderer does not provide
//transparency on class level
if ( !mRenderer->usesTransparency() )
{
myColor.setAlpha( mTransparencyLevel );
}
myTransparentPen.setColor( myColor );
p->setBrush( myTransparentBrush );
p->setPen( myTransparentPen );
if ( numRings == 1 )
{
ringTypePtr r = rings[0];
unsigned ringSize = r->first.size();
QPolygonF pa( ringSize );
for ( register unsigned int j = 0; j != ringSize; ++j )
{
pa[j].setX( r->first[j] );
pa[j].setY( r->second[j] );
}
p->drawPolygon( pa );
// draw vertex markers if in editing mode, but only to the main canvas
if ( mEditBuffer && renderContext.drawEditingInformation() )
{
for ( register unsigned int j = 0; j != ringSize; ++j )
{
drawVertexMarker( r->first[j], r->second[j], *p, mCurrentVertexMarkerType, mCurrentVertexMarkerSize );
}
}
delete rings[0];
}
else
{
// Store size here and use it in the loop to avoid penalty of
// multiple calls to size()
int numRings = rings.size();
for ( register int i = 0; i < numRings; ++i )
{
// Store the pointer in a variable with a short name so as to make
// the following code easier to type and read.
ringTypePtr r = rings[i];
// only do this once to avoid penalty of additional calls
unsigned ringSize = r->first.size();
// Transfer points to the array of QPointF
QPolygonF pa( ringSize );
for ( register unsigned int j = 0; j != ringSize; ++j )
{
pa[j].setX( r->first[j] );
pa[j].setY( r->second[j] );
}
path.addPolygon( pa );
// Tidy up the pointed to pairs of vectors as we finish with them
delete rings[i];
}
#if 0
// A bit of code to aid in working out what values of
// QgsClipper::minX, etc cause the X11 zoom bug.
int largestX = -std::numeric_limits<int>::max();
int smallestX = std::numeric_limits<int>::max();
int largestY = -std::numeric_limits<int>::max();
int smallestY = std::numeric_limits<int>::max();
for ( int i = 0; i < pa.size(); ++i )
{
largestX = qMax( largestX, pa.point( i ).x() );
smallestX = qMin( smallestX, pa.point( i ).x() );
largestY = qMax( largestY, pa.point( i ).y() );
smallestY = qMin( smallestY, pa.point( i ).y() );
}
QgsDebugMsg( QString( "Largest X coordinate was %1" ).arg( largestX ) );
QgsDebugMsg( QString( "Smallest X coordinate was %1" ).arg( smallestX ) );
QgsDebugMsg( QString( "Largest Y coordinate was %1" ).arg( largestY ) );
QgsDebugMsg( QString( "Smallest Y coordinate was %1" ).arg( smallestY ) );
#endif
//
// draw the polygon
//
p->drawPath( path );
// draw vertex markers if in editing mode, but only to the main canvas
if ( mEditBuffer && renderContext.drawEditingInformation() )
{
for ( int i = 0; i < path.elementCount(); ++i )
{
const QPainterPath::Element & e = path.elementAt( i );
drawVertexMarker( e.x, e.y, *p, mCurrentVertexMarkerType, mCurrentVertexMarkerSize );
}
}
}
//
//restore brush and pen to original
//
p->setBrush( brush );
p->setPen( pen );
} // totalPoints > 0
return ptr;
}
void QgsVectorLayer::drawRendererV2( QgsFeatureIterator &fit, QgsRenderContext& rendererContext, bool labeling )
{
@ -981,8 +633,6 @@ bool QgsVectorLayer::draw( QgsRenderContext& rendererContext )
mEnableBackbuffer = settings.value( "/Map/enableBackbuffer", 1 ).toBool();
#endif
if ( mUsingRendererV2 )
{
if ( !mRendererV2 )
return false;
@ -1023,147 +673,6 @@ bool QgsVectorLayer::draw( QgsRenderContext& rendererContext )
return true;
}
//draw ( p, viewExtent, theMapToPixelTransform, ct, drawingToEditingCanvas, 1., 1.);
if ( mRenderer )
{
// painter is active (begin has been called
/* Steps to draw the layer
1. get the features in the view extent by SQL query
2. read WKB for a feature
3. transform
4. draw
*/
QPen pen;
/*Pointer to a marker image*/
QImage marker;
//vertex marker type for selection
QgsVectorLayer::VertexMarkerType vertexMarker = QgsVectorLayer::NoMarker;
int vertexMarkerSize = 7;
if ( mEditBuffer )
{
// Destroy all cached geometries and clear the references to them
mCache->deleteCachedGeometries();
mCache->setCachedGeometriesRect( rendererContext.extent() );
vertexMarker = currentVertexMarkerType();
vertexMarkerSize = currentVertexMarkerSize();
mVertexMarkerOnlyForSelection = settings.value( "/qgis/digitizing/marker_only_for_selected", false ).toBool();
}
// int totalFeatures = pendingFeatureCount();
int featureCount = 0;
QgsFeature fet;
QgsAttributeList attributes = mRenderer->classificationAttributes();
bool labeling = false;
prepareLabelingAndDiagrams( rendererContext, attributes, labeling );
try
{
QgsFeatureIterator fit = getFeatures( QgsFeatureRequest()
.setFilterRect( rendererContext.extent() )
.setSubsetOfAttributes( attributes ) );
while ( fit.nextFeature( fet ) )
{
if ( !fet.geometry() )
continue; // skip features without geometry
if ( rendererContext.renderingStopped() )
{
break;
}
#ifndef Q_WS_MAC //MH: disable this on Mac for now to avoid problems with resizing
if ( mUpdateThreshold > 0 && 0 == featureCount % mUpdateThreshold )
{
emit screenUpdateRequested();
// emit drawingProgress( featureCount, totalFeatures );
qApp->processEvents();
}
else if ( featureCount % 1000 == 0 )
{
// emit drawingProgress( featureCount, totalFeatures );
qApp->processEvents();
}
// #else
// Q_UNUSED( totalFeatures );
#endif //Q_WS_MAC
// check if feature is selected
// only show selections of the current layer
// TODO: create a mechanism to let layer know whether it's current layer or not [MD]
bool sel = mSelectedFeatureIds.contains( fet.id() );
mCurrentVertexMarkerType = QgsVectorLayer::NoMarker;
mCurrentVertexMarkerSize = 7;
if ( mEditBuffer )
{
// Cache this for the use of (e.g.) modifying the feature's uncommitted geometry.
mCache->cacheGeometry( fet.id(), *fet.geometry() );
if ( !mVertexMarkerOnlyForSelection || sel )
{
mCurrentVertexMarkerType = vertexMarker;
mCurrentVertexMarkerSize = vertexMarkerSize;
}
}
//QgsDebugMsg(QString("markerScale before renderFeature(): %1").arg(markerScaleFactor));
// markerScalerFactore reflects the wanted scaling of the marker
double opacity = 1.0;
if ( !mRenderer->usesTransparency() )
{
opacity = ( mTransparencyLevel * 1.0 ) / 255.0;
}
mRenderer->renderFeature( rendererContext, fet, &marker, sel, opacity );
// markerScalerFactore now reflects the actual scaling of the marker that the render performed.
//QgsDebugMsg(QString("markerScale after renderFeature(): %1").arg(markerScaleFactor));
//double scale = rendererContext.scaleFactor() / markerScaleFactor;
drawFeature( rendererContext, fet, &marker );
if ( mRenderer->willRenderFeature( &fet ) && rendererContext.labelingEngine() )
{
if ( labeling )
{
rendererContext.labelingEngine()->registerFeature( this, fet, rendererContext );
}
if ( mDiagramRenderer )
{
rendererContext.labelingEngine()->registerDiagramFeature( this, fet, rendererContext );
}
}
++featureCount;
}
}
catch ( QgsCsException &cse )
{
Q_UNUSED( cse );
QgsDebugMsg( QString( "Failed to transform a point while drawing a feature with ID '%1'. Rendering stopped. %2" )
.arg( fet.id() ).arg( cse.what() ) );
return false;
}
QgsDebugMsg( QString( "Total features processed %1" ).arg( featureCount ) );
}
else
{
QgsDebugMsg( "QgsRenderer is null" );
}
if ( mEditBuffer )
{
QgsDebugMsg( QString( "Cached %1 geometries." ).arg( mCache->cachedGeometries().count() ) );
}
return true; // Assume success always
}
void QgsVectorLayer::drawVertexMarker( double x, double y, QPainter& p, QgsVectorLayer::VertexMarkerType type, int m )
{
if ( type == QgsVectorLayer::SemiTransparentCircle )
@ -1331,26 +840,6 @@ void QgsVectorLayer::setProviderEncoding( const QString& encoding )
}
}
const QgsRenderer* QgsVectorLayer::renderer() const
{
return mRenderer;
}
void QgsVectorLayer::setRenderer( QgsRenderer *r )
{
if ( !hasGeometryType() )
return;
if ( r != mRenderer )
{
if ( r )
setUsingRendererV2( false );
delete mRenderer;
mRenderer = r;
}
}
void QgsVectorLayer::setDiagramRenderer( QgsDiagramRendererV2* r )
{
delete mDiagramRenderer;
@ -2186,15 +1675,13 @@ bool QgsVectorLayer::writeXml( QDomNode & layer_node,
bool QgsVectorLayer::readSymbology( const QDomNode& node, QString& errorMessage )
{
Q_UNUSED( errorMessage );
if ( hasGeometryType() )
{
// try renderer v2 first
QDomElement rendererElement = node.firstChildElement( RENDERER_TAG_NAME );
if ( !rendererElement.isNull() )
{
// using renderer v2
setUsingRendererV2( true );
QgsFeatureRendererV2* r = QgsFeatureRendererV2::load( rendererElement );
if ( !r )
return false;
@ -2203,60 +1690,11 @@ bool QgsVectorLayer::readSymbology( const QDomNode& node, QString& errorMessage
}
else
{
// using renderer v1
setUsingRendererV2( false );
QgsFeatureRendererV2* r = QgsSymbologyV2Conversion::readOldRenderer( node, geometryType() );
if ( !r )
r = QgsFeatureRendererV2::defaultRenderer( geometryType() );
// create and bind a renderer to this layer
QDomNode singlenode = node.namedItem( "singlesymbol" );
QDomNode graduatednode = node.namedItem( "graduatedsymbol" );
QDomNode continuousnode = node.namedItem( "continuoussymbol" );
QDomNode uniquevaluenode = node.namedItem( "uniquevalue" );
QgsRenderer * renderer = 0;
int returnCode = 1;
if ( !singlenode.isNull() )
{
renderer = new QgsSingleSymbolRenderer( geometryType() );
returnCode = renderer->readXML( singlenode, *this );
}
else if ( !graduatednode.isNull() )
{
renderer = new QgsGraduatedSymbolRenderer( geometryType() );
returnCode = renderer->readXML( graduatednode, *this );
}
else if ( !continuousnode.isNull() )
{
renderer = new QgsContinuousColorRenderer( geometryType() );
returnCode = renderer->readXML( continuousnode, *this );
}
else if ( !uniquevaluenode.isNull() )
{
renderer = new QgsUniqueValueRenderer( geometryType() );
returnCode = renderer->readXML( uniquevaluenode, *this );
}
if ( !renderer )
{
errorMessage = tr( "Unknown renderer" );
return false;
}
if ( returnCode == 1 )
{
errorMessage = tr( "No renderer object" );
delete renderer;
return false;
}
else if ( returnCode == 2 )
{
errorMessage = tr( "Classification field not found" );
delete renderer;
return false;
}
mRenderer = renderer;
setRendererV2( r );
}
// get and set the display field if it exists.
@ -2578,51 +2016,19 @@ QgsAttributeEditorElement* QgsVectorLayer::attributeEditorElementFromDomElement(
bool QgsVectorLayer::writeSymbology( QDomNode& node, QDomDocument& doc, QString& errorMessage ) const
{
Q_UNUSED( errorMessage );
QDomElement mapLayerNode = node.toElement();
if ( hasGeometryType() )
{
if ( mUsingRendererV2 )
{
QDomElement rendererElement = mRendererV2->save( doc );
node.appendChild( rendererElement );
}
else
{
// use scale dependent visibility flag
mapLayerNode.setAttribute( "scaleBasedLabelVisibilityFlag", mLabel->scaleBasedVisibility() ? 1 : 0 );
mapLayerNode.setAttribute( "minLabelScale", QString::number( mLabel->minScale() ) );
mapLayerNode.setAttribute( "maxLabelScale", QString::number( mLabel->maxScale() ) );
//classification field(s)
QgsAttributeList attributes = mRenderer->classificationAttributes();
const QgsFields& providerFields = mDataProvider->fields();
for ( QgsAttributeList::const_iterator it = attributes.begin(); it != attributes.end(); ++it )
{
QDomElement classificationElement = doc.createElement( "classificationattribute" );
QDomText classificationText = doc.createTextNode( providerFields[*it].name() );
classificationElement.appendChild( classificationText );
node.appendChild( classificationElement );
}
// renderer settings
const QgsRenderer * myRenderer = renderer();
if ( myRenderer )
{
if ( !myRenderer->writeXML( node, doc, *this ) )
{
errorMessage = tr( "renderer failed to save" );
return false;
}
}
else
{
QgsDebugMsg( "no renderer" );
errorMessage = tr( "no renderer" );
return false;
}
}
//save customproperties (for labeling ng)
writeCustomProperties( node, doc );
@ -2888,8 +2294,6 @@ bool QgsVectorLayer::readSld( const QDomNode& node, QString& errorMessage )
if ( hasGeometryType() )
{
setUsingRendererV2( true );
QgsFeatureRendererV2* r = QgsFeatureRendererV2::loadSld( node, geometryType(), errorMessage );
if ( !r )
return false;
@ -2910,17 +2314,9 @@ bool QgsVectorLayer::writeSld( QDomNode& node, QDomDocument& doc, QString& error
node.appendChild( nameNode );
if ( hasGeometryType() )
{
if ( mUsingRendererV2 )
{
node.appendChild( mRendererV2->writeSld( doc, *this ) );
}
else
{
node.appendChild( doc.createComment( "Old Renderer not supported yet" ) );
return false;
}
}
return true;
}
@ -3373,135 +2769,6 @@ int QgsVectorLayer::currentVertexMarkerSize()
return settings.value( "/qgis/digitizing/marker_size", 3 ).toInt();
}
void QgsVectorLayer::drawFeature( QgsRenderContext &renderContext,
QgsFeature& fet,
QImage * marker )
{
QPainter *p = renderContext.painter();
// Only have variables, etc outside the switch() statement that are
// used in all cases of the statement (otherwise they may get
// executed, but never used, in a bit of code where performance is
// critical).
if ( ! fet.isValid() )
{
return;
}
QgsGeometry* geom = fet.geometry();
if ( !geom )
{
return;
}
unsigned char* feature = geom->asWkb();
QGis::WkbType wkbType = geom->wkbType();
switch ( wkbType )
{
case QGis::WKBPoint:
case QGis::WKBPoint25D:
{
double x = *(( double * )( feature + 5 ) );
double y = *(( double * )( feature + 5 + sizeof( double ) ) );
transformPoint( x, y, &renderContext.mapToPixel(), renderContext.coordinateTransform() );
if ( qAbs( x ) > QgsClipper::MAX_X ||
qAbs( y ) > QgsClipper::MAX_Y )
{
break;
}
//QPointF pt(x - (marker->width()/2), y - (marker->height()/2));
QPointF pt( x * renderContext.rasterScaleFactor() - ( marker->width() / 2 ),
y * renderContext.rasterScaleFactor() - ( marker->height() / 2 ) );
p->save();
//p->scale(markerScaleFactor,markerScaleFactor);
p->scale( 1.0 / renderContext.rasterScaleFactor(), 1.0 / renderContext.rasterScaleFactor() );
p->drawImage( pt, *marker );
p->restore();
break;
}
case QGis::WKBMultiPoint:
case QGis::WKBMultiPoint25D:
{
unsigned char *ptr = feature + 5;
unsigned int nPoints = *(( int* )ptr );
ptr += 4;
p->save();
//p->scale(markerScaleFactor, markerScaleFactor);
p->scale( 1.0 / renderContext.rasterScaleFactor(), 1.0 / renderContext.rasterScaleFactor() );
for ( register unsigned int i = 0; i < nPoints; ++i )
{
ptr += 5;
double x = *(( double * ) ptr );
ptr += sizeof( double );
double y = *(( double * ) ptr );
ptr += sizeof( double );
if ( wkbType == QGis::WKBMultiPoint25D ) // ignore Z value
ptr += sizeof( double );
transformPoint( x, y, &renderContext.mapToPixel(), renderContext.coordinateTransform() );
//QPointF pt(x - (marker->width()/2), y - (marker->height()/2));
//QPointF pt(x/markerScaleFactor - (marker->width()/2), y/markerScaleFactor - (marker->height()/2));
QPointF pt( x * renderContext.rasterScaleFactor() - ( marker->width() / 2 ),
y * renderContext.rasterScaleFactor() - ( marker->height() / 2 ) );
//QPointF pt( x, y );
// Work around a +/- 32768 limitation on coordinates
if ( qAbs( x ) <= QgsClipper::MAX_X &&
qAbs( y ) <= QgsClipper::MAX_Y )
p->drawImage( pt, *marker );
}
p->restore();
break;
}
case QGis::WKBLineString:
case QGis::WKBLineString25D:
{
drawLineString( feature, renderContext );
break;
}
case QGis::WKBMultiLineString:
case QGis::WKBMultiLineString25D:
{
unsigned char* ptr = feature + 5;
unsigned int numLineStrings = *(( int* )ptr );
ptr = feature + 9;
for ( register unsigned int jdx = 0; jdx < numLineStrings; jdx++ )
{
ptr = drawLineString( ptr, renderContext );
}
break;
}
case QGis::WKBPolygon:
case QGis::WKBPolygon25D:
{
drawPolygon( feature, renderContext );
break;
}
case QGis::WKBMultiPolygon:
case QGis::WKBMultiPolygon25D:
{
unsigned char *ptr = feature + 5;
unsigned int numPolygons = *(( int* )ptr );
ptr = feature + 9;
for ( register unsigned int kdx = 0; kdx < numPolygons; kdx++ )
ptr = drawPolygon( ptr, renderContext );
break;
}
default:
QgsDebugMsg( QString( "Unknown WkbType 0x%1 ENCOUNTERED" ).arg( wkbType, 0, 16 ) );
break;
}
}
void QgsVectorLayer::setCoordinateSystem()
@ -3524,37 +2791,6 @@ void QgsVectorLayer::setCoordinateSystem()
}
}
// Convenience function to transform the given point
inline void QgsVectorLayer::transformPoint(
double& x, double& y,
const QgsMapToPixel* mtp,
const QgsCoordinateTransform* ct )
{
// transform the point
if ( ct )
{
double z = 0;
ct->transformInPlace( x, y, z );
}
// transform from projected coordinate system to pixel
// position on map canvas
mtp->transformInPlace( x, y );
}
inline void QgsVectorLayer::transformPoints(
QVector<double>& x, QVector<double>& y, QVector<double>& z,
QgsRenderContext &renderContext )
{
// transform the point
if ( renderContext.coordinateTransform() )
renderContext.coordinateTransform()->transformInPlace( x, y, z );
// transform from projected coordinate system to pixel
// position on map canvas
renderContext.mapToPixel().transformInPlace( x, y );
}
const QString QgsVectorLayer::displayField() const
{
@ -3762,25 +2998,12 @@ void QgsVectorLayer::setRendererV2( QgsFeatureRendererV2 *r )
if ( r != mRendererV2 )
{
if ( r )
setUsingRendererV2( true );
delete mRendererV2;
mRendererV2 = r;
mSymbolFeatureCounted = false;
mSymbolFeatureCountMap.clear();
}
}
bool QgsVectorLayer::isUsingRendererV2()
{
return mUsingRendererV2;
}
void QgsVectorLayer::setUsingRendererV2( bool usingRendererV2 )
{
if ( !hasGeometryType() )
return;
mUsingRendererV2 = usingRendererV2;
}

42
src/core/qgsvectorlayer.h
View File

@ -315,12 +315,6 @@ class CORE_EXPORT QgsVectorLayer : public QgsMapLayer
/** Returns the bounding box of the selected features. If there is no selection, QgsRectangle(0,0,0,0) is returned */
QgsRectangle boundingBoxOfSelected();
/** Returns a pointer to the renderer */
const QgsRenderer* renderer() const;
/** Sets the renderer. If a renderer is already present, it is deleted */
void setRenderer( QgsRenderer * r );
/** Sets diagram rendering object (takes ownership) */
void setDiagramRenderer( QgsDiagramRendererV2* r );
const QgsDiagramRendererV2* diagramRenderer() const { return mDiagramRenderer; }
@ -335,14 +329,6 @@ class CORE_EXPORT QgsVectorLayer : public QgsMapLayer
* @note added in 1.4
*/
void setRendererV2( QgsFeatureRendererV2* r );
/** Return whether using renderer V2.
* @note added in 1.4
*/
bool isUsingRendererV2();
/** set whether to use renderer V2 for drawing.
* @note added in 1.4
*/
void setUsingRendererV2( bool usingRendererV2 );
/** Draw layer with renderer V2.
* @note added in 1.4
@ -931,28 +917,6 @@ class CORE_EXPORT QgsVectorLayer : public QgsMapLayer
*/
bool setDataProvider( QString const & provider );
/** Draws features. May cause projections exceptions to be generated
* (i.e., code that calls this function needs to catch them) */
void drawFeature( QgsRenderContext &renderContext,
QgsFeature& fet,
QImage* marker );
/** Convenience function to transform the given point */
void transformPoint( double& x, double& y,
const QgsMapToPixel* mtp, const QgsCoordinateTransform* ct );
void transformPoints( QVector<double>& x, QVector<double>& y, QVector<double>& z, QgsRenderContext &renderContext );
/** Draw the linestring as given in the WKB format. Returns a pointer
* to the byte after the end of the line string binary data stream (WKB).
*/
unsigned char *drawLineString( unsigned char *WKBlinestring, QgsRenderContext &renderContext );
/** Draw the polygon as given in the WKB format. Returns a pointer to
* the byte after the end of the polygon binary data stream (WKB).
*/
unsigned char *drawPolygon( unsigned char *WKBpolygon, QgsRenderContext &renderContext );
/** Goes through all features and finds a free id (e.g. to give it temporarily to a not-commited feature) */
QgsFeatureId findFreeId();
@ -1046,14 +1010,8 @@ class CORE_EXPORT QgsVectorLayer : public QgsMapLayer
int mWkbType;
/** Renderer object which holds the information about how to display the features */
QgsRenderer *mRenderer;
/** Renderer V2 */
QgsFeatureRendererV2 *mRendererV2;
/** whether to use V1 or V2 renderer */
bool mUsingRendererV2;
/** Label */
QgsLabel *mLabel;

1
src/core/renderer/qgscontinuouscolorrenderer.cpp
View File

@ -237,7 +237,6 @@ int QgsContinuousColorRenderer::readXML( const QDomNode& rnode, QgsVectorLayer&
usy->readXML( usymbolnode, &vl );
setMaximumSymbol( usy );
}
vl.setRenderer( this );
return 0;
}

1
src/core/renderer/qgsgraduatedsymbolrenderer.cpp
View File

@ -282,7 +282,6 @@ int QgsGraduatedSymbolRenderer::readXML( const QDomNode& rnode, QgsVectorLayer&
symbolnode = symbolnode.nextSibling();
}
updateSymbolAttributes();
vl.setRenderer( this );
return 0;
}

1
src/core/renderer/qgssinglesymbolrenderer.cpp
View File

@ -215,7 +215,6 @@ int QgsSingleSymbolRenderer::readXML( const QDomNode& rnode, QgsVectorLayer& vl
//create a renderer and add it to the vector layer
addSymbol( sy );
vl.setRenderer( this );
return 0;
}

1
src/core/renderer/qgsuniquevaluerenderer.cpp
View File

@ -236,7 +236,6 @@ int QgsUniqueValueRenderer::readXML( const QDomNode& rnode, QgsVectorLayer& vl )
symbolnode = symbolnode.nextSibling();
}
updateSymbolAttributes();
vl.setRenderer( this );
return 0;
}

450
src/core/symbology-ng/qgssymbologyv2conversion.cpp
View File

@ -14,13 +14,8 @@
***************************************************************************/
#include "qgssymbologyv2conversion.h"
#include "qgssinglesymbolrenderer.h"
#include "qgsgraduatedsymbolrenderer.h"
#include "qgsuniquevaluerenderer.h"
#include "qgssymbol.h"
#include "qgsvectorlayer.h"
#include "qgslogger.h"
#include "qgssymbologyutils.h"
#include "qgsmarkersymbollayerv2.h"
#include "qgslinesymbollayerv2.h"
@ -30,21 +25,122 @@
#include "qgscategorizedsymbolrendererv2.h"
QgsSymbolV2* QgsSymbologyV2Conversion::symbolV1toV2( const QgsSymbol* s )
struct QgsOldSymbolMeta
{
switch ( s->type() )
QString lowerValue;
QString upperValue;
QString label;
};
static QgsOldSymbolMeta readSymbolMeta( const QDomNode& synode )
{
QgsOldSymbolMeta meta;
QDomNode lvalnode = synode.namedItem( "lowervalue" );
if ( ! lvalnode.isNull() )
{
QDomElement lvalelement = lvalnode.toElement();
if ( lvalelement.attribute( "null" ).toInt() == 1 )
{
meta.lowerValue = QString::null;
}
else
{
meta.lowerValue = lvalelement.text();
}
}
QDomNode uvalnode = synode.namedItem( "uppervalue" );
if ( ! uvalnode.isNull() )
{
QDomElement uvalelement = uvalnode.toElement();
meta.upperValue = uvalelement.text();
}
QDomNode labelnode = synode.namedItem( "label" );
if ( ! labelnode.isNull() )
{
QDomElement labelelement = labelnode.toElement();
meta.label = labelelement.text();
}
return meta;
}
static QColor readSymbolColor( const QDomNode& synode, bool fillColor )
{
QDomNode cnode = synode.namedItem( fillColor ? "fillcolor" : "outlinecolor" );
QDomElement celement = cnode.toElement();
int red = celement.attribute( "red" ).toInt();
int green = celement.attribute( "green" ).toInt();
int blue = celement.attribute( "blue" ).toInt();
return QColor( red, green, blue );
}
static double readOutlineWidth( const QDomNode& synode )
{
QDomNode outlwnode = synode.namedItem( "outlinewidth" );
QDomElement outlwelement = outlwnode.toElement();
return outlwelement.text().toDouble();
}
static Qt::PenStyle readOutlineStyle( const QDomNode& synode )
{
QDomNode outlstnode = synode.namedItem( "outlinestyle" );
QDomElement outlstelement = outlstnode.toElement();
return QgsSymbologyUtils::qString2PenStyle( outlstelement.text() );
}
static Qt::BrushStyle readBrushStyle( const QDomNode& synode )
{
QDomNode fillpnode = synode.namedItem( "fillpattern" );
QDomElement fillpelement = fillpnode.toElement();
return QgsSymbologyUtils::qString2BrushStyle( fillpelement.text() );
}
static QString readMarkerSymbolName( const QDomNode& synode )
{
QDomNode psymbnode = synode.namedItem( "pointsymbol" );
if ( ! psymbnode.isNull() )
{
QDomElement psymbelement = psymbnode.toElement();
return psymbelement.text();
}
return QString("hard:circle");
}
static float readMarkerSymbolSize( const QDomNode& synode )
{
QDomNode psizenode = synode.namedItem( "pointsize" );
if ( ! psizenode.isNull() )
{
QDomElement psizeelement = psizenode.toElement();
return psizeelement.text().toFloat();
}
return DEFAULT_POINT_SIZE;
}
static QgsSymbolV2* readOldSymbol( const QDomNode& synode, QGis::GeometryType geomType )
{
switch ( geomType )
{
case QGis::Point:
{
QgsMarkerSymbolLayerV2* sl = NULL;
double size = s->pointSize();
double size = readMarkerSymbolSize( synode );
double angle = 0; // rotation only from classification field
QString symbolName = s->pointSymbolName();
QString symbolName = readMarkerSymbolName( synode );
if ( symbolName.startsWith( "hard:" ) )
{
// simple symbol marker
QColor color = s->fillColor();
QColor borderColor = s->color();
QColor color = readSymbolColor( synode, true );
QColor borderColor = readSymbolColor( synode, false );
QString name = symbolName.mid( 5 );
sl = new QgsSimpleMarkerSymbolLayerV2( name, color, borderColor, size, angle );
}
@ -61,9 +157,9 @@ QgsSymbolV2* QgsSymbologyV2Conversion::symbolV1toV2( const QgsSymbol* s )
case QGis::Line:
{
QColor color = s->color();
double width = s->lineWidth();
Qt::PenStyle penStyle = s->pen().style();
QColor color = readSymbolColor( synode, false );
double width = readOutlineWidth( synode );
Qt::PenStyle penStyle = readOutlineStyle( synode );
QgsLineSymbolLayerV2* sl = new QgsSimpleLineSymbolLayerV2( color, width, penStyle );
QgsSymbolLayerV2List layers;
@ -73,11 +169,11 @@ QgsSymbolV2* QgsSymbologyV2Conversion::symbolV1toV2( const QgsSymbol* s )
case QGis::Polygon:
{
QColor color = s->fillColor();
QColor borderColor = s->color();
Qt::BrushStyle brushStyle = s->brush().style();
Qt::PenStyle borderStyle = s->pen().style();
double borderWidth = s->lineWidth();
QColor color = readSymbolColor( synode, true );
QColor borderColor = readSymbolColor( synode, false );
Qt::BrushStyle brushStyle = readBrushStyle( synode );
Qt::PenStyle borderStyle = readOutlineStyle( synode );
double borderWidth = readOutlineWidth( synode );
QgsFillSymbolLayerV2* sl = new QgsSimpleFillSymbolLayerV2( color, brushStyle, borderColor, borderStyle, borderWidth );
QgsSymbolLayerV2List layers;
@ -90,253 +186,163 @@ QgsSymbolV2* QgsSymbologyV2Conversion::symbolV1toV2( const QgsSymbol* s )
}
}
QgsSymbol* QgsSymbologyV2Conversion::symbolV2toV1( QgsSymbolV2* s )
{
if ( s == NULL || s->symbolLayerCount() == 0 )
return NULL;
// we will use only the first symbol layer
QgsSymbolLayerV2* sl = s->symbolLayer( 0 );
switch ( sl->type() )
static QgsFeatureRendererV2* readOldSingleSymbolRenderer( const QDomNode& rnode, QGis::GeometryType geomType )
{
case QgsSymbolV2::Marker:
{
QgsMarkerSymbolLayerV2* msl = static_cast<QgsMarkerSymbolLayerV2*>( sl );
QgsSymbol* sOld = new QgsSymbol( QGis::Point );
sOld->setFillColor( sl->color() );
sOld->setFillStyle( Qt::SolidPattern );
sOld->setPointSize( msl->size() );
if ( sl->layerType() == "SimpleMarker" )
{
QgsSimpleMarkerSymbolLayerV2* smsl = static_cast<QgsSimpleMarkerSymbolLayerV2*>( sl );
sOld->setColor( smsl->borderColor() );
sOld->setNamedPointSymbol( "hard:" + smsl->name() );
}
else if ( sl->layerType() == "SvgMarker" )
{
QgsSvgMarkerSymbolLayerV2* smsl = static_cast<QgsSvgMarkerSymbolLayerV2*>( sl );
sOld->setNamedPointSymbol( "svg:" + smsl->path() );
}
return sOld;
}
break;
QDomNode synode = rnode.namedItem( "symbol" );
if ( synode.isNull() )
return 0;
case QgsSymbolV2::Line:
{
QgsLineSymbolLayerV2* lsl = static_cast<QgsLineSymbolLayerV2*>( sl );
QgsSymbol* sOld = new QgsSymbol( QGis::Line );
sOld->setColor( sl->color() );
sOld->setLineWidth( lsl->width() );
if ( sl->layerType() == "SimpleLine" )
{
// add specific settings
QgsSimpleLineSymbolLayerV2* slsl = static_cast<QgsSimpleLineSymbolLayerV2*>( sl );
sOld->setLineStyle( slsl->penStyle() );
}
return sOld;
QgsSymbolV2* sy2 = readOldSymbol( synode, geomType );
QgsSingleSymbolRendererV2* r = new QgsSingleSymbolRendererV2( sy2 );
return r;
}
case QgsSymbolV2::Fill:
static QgsFeatureRendererV2* readOldGraduatedSymbolRenderer( const QDomNode& rnode, QGis::GeometryType geomType )
{
QgsSymbol* sOld = new QgsSymbol( QGis::Polygon );
sOld->setFillColor( sl->color() );
if ( sl->layerType() == "SimpleFill" )
QDomNode modeNode = rnode.namedItem( "mode" );
QString modeValue = modeNode.toElement().text();
QDomNode classnode = rnode.namedItem( "classificationfield" );
QString classificationField = classnode.toElement().text();
QgsGraduatedSymbolRendererV2::Mode m = QgsGraduatedSymbolRendererV2::Custom;
if ( modeValue == "Empty" )
{
// add specifc settings
QgsSimpleFillSymbolLayerV2* sfsl = static_cast<QgsSimpleFillSymbolLayerV2*>( sl );
sOld->setColor( sfsl->borderColor() );
sOld->setLineWidth( sfsl->borderWidth() );
sOld->setLineStyle( sfsl->borderStyle() );
sOld->setFillStyle( sfsl->brushStyle() );
m = QgsGraduatedSymbolRendererV2::Custom;
}
return sOld;
else if ( modeValue == "Quantile" )
{
m = QgsGraduatedSymbolRendererV2::Quantile;
}
else //default
{
m = QgsGraduatedSymbolRendererV2::EqualInterval;
}
return NULL; // should never get here
}
void QgsSymbologyV2Conversion::rendererV1toV2( QgsVectorLayer* layer )
{
if ( layer->isUsingRendererV2() )
return;
const QgsRenderer* r = layer->renderer();
if ( r == NULL )
return;
QgsFeatureRendererV2* r2final = NULL;
QString rtype = r->name();
if ( rtype == "Single Symbol" )
{
const QgsSingleSymbolRenderer* ssr = dynamic_cast<const QgsSingleSymbolRenderer*>( r );
if ( ssr == NULL )
return;
QgsSymbolV2* symbol = symbolV1toV2( ssr->symbol() );
QgsSingleSymbolRendererV2* r2 = new QgsSingleSymbolRendererV2( symbol );
r2final = r2;
}
else if ( rtype == "Graduated Symbol" )
{
const QgsGraduatedSymbolRenderer* gsr = dynamic_cast<const QgsGraduatedSymbolRenderer*>( r );
if ( gsr == NULL )
return;
QString attrName;
const QgsFields& fields = layer->pendingFields();
int fldIdx = gsr->classificationField();
if ( fldIdx >= 0 && fldIdx < fields.count() )
{
attrName = fields[fldIdx].name();
}
// load ranges and symbols
QgsRangeList ranges;
foreach ( const QgsSymbol* sym, gsr->symbols() )
QDomNode symbolnode = rnode.namedItem( "symbol" );
while ( !symbolnode.isNull() )
{
double lowerValue = sym->lowerValue().toDouble();
double upperValue = sym->upperValue().toDouble();
QString label = sym->label();
QgsSymbolV2* symbolv2 = readOldSymbol( symbolnode, geomType );
if ( symbolv2 )
{
QgsOldSymbolMeta meta = readSymbolMeta( symbolnode );
double lowerValue = meta.lowerValue.toDouble();
double upperValue = meta.upperValue.toDouble();
QString label = meta.label;
if ( label.isEmpty() )
label = QString( "%1 - %2" ).arg( lowerValue, -1, 'f', 3 ).arg( upperValue, -1, 'f', 3 );
QgsSymbolV2* symbolv2 = symbolV1toV2( sym );
ranges.append( QgsRendererRangeV2( lowerValue, upperValue, symbolv2, label ) );
}
QgsGraduatedSymbolRendererV2* r2 = new QgsGraduatedSymbolRendererV2( attrName, ranges );
// find out mode
QgsGraduatedSymbolRendererV2::Mode m = QgsGraduatedSymbolRendererV2::Custom;
switch ( gsr->mode() )
{
case QgsGraduatedSymbolRenderer::EqualInterval: m = QgsGraduatedSymbolRendererV2::EqualInterval; break;
case QgsGraduatedSymbolRenderer::Quantile: m = QgsGraduatedSymbolRendererV2::Quantile; break;
case QgsGraduatedSymbolRenderer::Empty: m = QgsGraduatedSymbolRendererV2::Custom; break;
}
r2->setMode( m );
// source symbol, color ramp not set (unknown)
r2final = r2;
}
else if ( rtype == "Continuous Color" )
{
// TODO
}
else if ( rtype == "Unique Value" )
{
const QgsUniqueValueRenderer* uvr = dynamic_cast<const QgsUniqueValueRenderer*>( r );
if ( uvr == NULL )
return;
QString attrName;
const QgsFields& fields = layer->pendingFields();
int fldIdx = uvr->classificationField();
if ( fldIdx >= 0 && fldIdx < fields.count() )
{
attrName = fields[fldIdx].name();
symbolnode = symbolnode.nextSibling();
}
// create renderer
QgsGraduatedSymbolRendererV2* r = new QgsGraduatedSymbolRendererV2( classificationField, ranges );
r->setMode( m );
return r;
}
static QgsFeatureRendererV2* readOldUniqueValueRenderer( const QDomNode& rnode, QGis::GeometryType geomType )
{
QDomNode classnode = rnode.namedItem( "classificationfield" );
QString classificationField = classnode.toElement().text();
// read categories and symbols
QgsCategoryList cats;
foreach ( QgsSymbol* sym, uvr->symbols() )
QDomNode symbolnode = rnode.namedItem( "symbol" );
while ( !symbolnode.isNull() )
{
QVariant value = QVariant( sym->lowerValue() );
QString label = sym->label();
QgsSymbolV2* symbolv2 = readOldSymbol( symbolnode, geomType );
if ( symbolv2 )
{
QgsOldSymbolMeta meta = readSymbolMeta( symbolnode );
QVariant value = QVariant( meta.lowerValue );
QString label = meta.label;
if ( label.isEmpty() )
label = value.toString();
QgsSymbolV2* symbolv2 = symbolV1toV2( sym );
cats.append( QgsRendererCategoryV2( value, symbolv2, label ) );
}
QgsCategorizedSymbolRendererV2* r2 = new QgsCategorizedSymbolRendererV2( attrName, cats );
symbolnode = symbolnode.nextSibling();
}
QgsCategorizedSymbolRendererV2* r = new QgsCategorizedSymbolRendererV2( classificationField, cats );
// source symbol and color ramp are not set (unknown)
r2final = r2;
return r;
}
if ( r2final == NULL )
QgsFeatureRendererV2* QgsSymbologyV2Conversion::readOldRenderer( const QDomNode& layerNode, QGis::GeometryType geomType )
{
r2final = QgsFeatureRendererV2::defaultRenderer( layer->geometryType() );
}
QDomNode singlenode = layerNode.namedItem( "singlesymbol" );
QDomNode graduatednode = layerNode.namedItem( "graduatedsymbol" );
QDomNode continuousnode = layerNode.namedItem( "continuoussymbol" );
QDomNode uniquevaluenode = layerNode.namedItem( "uniquevalue" );
// change of renderers
layer->setUsingRendererV2( true );
layer->setRendererV2( r2final );
layer->setRenderer( NULL );
}
void QgsSymbologyV2Conversion::rendererV2toV1( QgsVectorLayer* layer )
if ( !singlenode.isNull() )
{
if ( !layer->isUsingRendererV2() )
return;
QgsFeatureRendererV2* r2 = layer->rendererV2();
if ( r2 == NULL )
return;
QgsRenderer* rfinal = NULL;
QString r2type = r2->type();
if ( r2type == "singleSymbol" )
return readOldSingleSymbolRenderer( singlenode, geomType );
}
else if ( !graduatednode.isNull() )
{
QgsSingleSymbolRendererV2* ssr2 = static_cast<QgsSingleSymbolRendererV2*>( r2 );
QgsSingleSymbolRenderer* r = new QgsSingleSymbolRenderer( layer->geometryType() );
r->addSymbol( symbolV2toV1( ssr2->symbol() ) );
rfinal = r;
return readOldGraduatedSymbolRenderer( graduatednode, geomType );
}
else if ( r2type == "graduatedSymbol" )
else if ( !continuousnode.isNull() )
{
QgsGraduatedSymbolRendererV2* gsr2 = static_cast<QgsGraduatedSymbolRendererV2*>( r2 );
QgsGraduatedSymbolRenderer::Mode m;
switch ( gsr2->mode() )
return 0;
}
else if ( !uniquevaluenode.isNull() )
{
case QgsGraduatedSymbolRendererV2::EqualInterval: m = QgsGraduatedSymbolRenderer::EqualInterval; break;
case QgsGraduatedSymbolRendererV2::Quantile: m = QgsGraduatedSymbolRenderer::Quantile; break;
default: m = QgsGraduatedSymbolRenderer::Empty; break;
return readOldUniqueValueRenderer( uniquevaluenode, geomType );
}
QgsGraduatedSymbolRenderer* r = new QgsGraduatedSymbolRenderer( layer->geometryType(), m );
return 0;
}
r->setClassificationField( layer->fieldNameIndex( gsr2->classAttribute() ) );
foreach ( QgsRendererRangeV2 range, gsr2->ranges() )
/*
UNSUPPORTED RENDERER: continuous color
QDomNode classnode = rnode.namedItem( "classificationfield" );
QDomNode polyoutlinenode = rnode.namedItem( "polygonoutline" );
QString polyoutline = polyoutlinenode.toElement().text();
if ( polyoutline == "0" )
drawPolygonOutline = false;
else if ( polyoutline == "1" )
drawPolygonOutline = true;
QDomNode lowernode = rnode.namedItem( "lowestsymbol" );
lowSymbol = readOldSymbol( lowernode.namedItem( "symbol" ), geomType );
QDomNode uppernode = rnode.namedItem( "highestsymbol" );
highSymbol = readOldSymbol( uppernode.namedItem( "symbol" ), geomType );
UNSUPPORTED SYMBOL PROPERTY: point size units
QDomNode psizeunitnodes = synode.namedItem( "pointsizeunits" );
if ( ! psizeunitnodes.isNull() )
{
QgsSymbol* s = symbolV2toV1( range.symbol() );
s->setLowerValue( QString::number( range.lowerValue(), 'f', 5 ) );
s->setUpperValue( QString::number( range.upperValue(), 'f', 5 ) );
s->setLabel( range.label() );
r->addSymbol( s );
QDomElement psizeunitelement = psizeunitnodes.toElement();
QgsDebugMsg( QString( "psizeunitelement:%1" ).arg( psizeunitelement.text() ) );
setPointSizeUnits( psizeunitelement.text().compare( "mapunits", Qt::CaseInsensitive ) == 0 );
}
rfinal = r;
}
else if ( r2type == "categorizedSymbol" )
{
QgsCategorizedSymbolRendererV2* csr2 = static_cast<QgsCategorizedSymbolRendererV2*>( r2 );
UNSUPPORTED SYMBOL PROPERTY: data-defined rotation / scale / symbol name
QgsUniqueValueRenderer* r = new QgsUniqueValueRenderer( layer->geometryType() );
rotationClassificationFieldName = synode.namedItem( "rotationclassificationfieldname" ).toElement().text();
scaleClassificationFieldName = synode.namedItem( "scaleclassificationfield" ).toElement().text();
symbolFieldName = synode.namedItem( "symbolfieldname" ).toElement().text();
r->setClassificationField( layer->fieldNameIndex( csr2->classAttribute() ) );
UNSUPPORTED SYMBOL PROPERTY: texture
foreach ( QgsRendererCategoryV2 cat, csr2->categories() )
{
QgsSymbol* s = symbolV2toV1( cat.symbol() );
QString val = cat.value().toString();
s->setLowerValue( val );
s->setUpperValue( val );
r->insertValue( val, s );
}
rfinal = r;
}
if ( rfinal == NULL )
{
rfinal = new QgsSingleSymbolRenderer( layer->geometryType() );
}
layer->setUsingRendererV2( false );
layer->setRendererV2( NULL );
layer->setRenderer( rfinal );
}
QDomNode texturepathnode = synode.namedItem( "texturepath" );
QDomElement texturepathelement = texturepathnode.toElement();
setCustomTexture( QgsProject::instance()->readPath( texturepathelement.text() ) );
*/

27
src/core/symbology-ng/qgssymbologyv2conversion.h
View File

@ -15,30 +15,19 @@
#ifndef QGSSYMBOLOGYV2CONVERSION_H
#define QGSSYMBOLOGYV2CONVERSION_H
class QgsSymbol;
class QgsSymbolV2;
class QgsVectorLayer;
class QDomNode;
class QgsFeatureRendererV2;
#include "qgis.h"
/** This class is not a part of public API, it is intended only for compatibility with older versions of QGIS (1.x) */
class CORE_EXPORT QgsSymbologyV2Conversion
{
public:
//! return a symbol in new symbology as close as possible to old symbol
//! @note not all properties will be preserved
static QgsSymbolV2* symbolV1toV2( const QgsSymbol* s );
//! return a symbol in old symbology as close as possible to new symbol
//! @note not all properties will be preserved
static QgsSymbol* symbolV2toV1( QgsSymbolV2* s );
//! convert layer from old symbology to new symbology
//! @note not all properties will be preserved
static void rendererV1toV2( QgsVectorLayer* layer );
//! convert layer from new symbology to old symbology
//! @note not all properties will be preserved
static void rendererV2toV1( QgsVectorLayer* layer );
/** Read old renderer definition from XML and create matching new renderer */
static QgsFeatureRendererV2* readOldRenderer( const QDomNode& layerNode, QGis::GeometryType geomType );
};
#endif // QGSSYMBOLOGYV2CONVERSION_H

17
src/gui/qgsattributeeditor.cpp
View File

@ -432,23 +432,6 @@ QWidget *QgsAttributeEditor::createAttributeEditor( QWidget *parent, QWidget *ed
{
QMap<QString, QString> classes;
const QgsUniqueValueRenderer *uvr = dynamic_cast<const QgsUniqueValueRenderer *>( vl->renderer() );
if ( uvr )
{
const QList<QgsSymbol *> symbols = uvr->symbols();
for ( int i = 0; i < symbols.size(); i++ )
{
QString label = symbols[i]->label();
QString name = symbols[i]->lowerValue();
if ( label == "" )
label = name;
classes.insert( name, label );
}
}
const QgsCategorizedSymbolRendererV2 *csr = dynamic_cast<const QgsCategorizedSymbolRendererV2 *>( vl->rendererV2() );
if ( csr )
{

7
src/gui/symbology-ng/qgsrendererv2propertiesdialog.cpp
View File

@ -100,13 +100,6 @@ QgsRendererV2PropertiesDialog::QgsRendererV2PropertiesDialog( QgsVectorLayer* la
cboRenderers->setCurrentIndex( -1 ); // set no current renderer
// if the layer doesn't use renderer V2, let's start using it!
if ( !mLayer->isUsingRendererV2() )
{
mLayer->setRendererV2( QgsFeatureRendererV2::defaultRenderer( mLayer->geometryType() ) );
mLayer->setUsingRendererV2( true );
}
// setup slot rendererChanged()
connect( cboRenderers, SIGNAL( currentIndexChanged( int ) ), this, SLOT( rendererChanged() ) );

3
src/mapserver/qgssldparser.cpp
View File

@ -277,7 +277,6 @@ QList<QgsMapLayer*> QgsSLDParser::mapLayerFromStyle( const QString& layerName, c
{
QgsFeatureRendererV2* r = rendererFromUserStyle( userStyleElement, v );
v->setRendererV2( r );
v->setUsingRendererV2( true );
labelSettingsFromUserStyle( userStyleElement, v );
#ifdef DIAGRAMSERVER
overlaysFromUserStyle( userStyleElement, v );
@ -394,7 +393,6 @@ QList<QgsMapLayer*> QgsSLDParser::mapLayerFromStyle( const QString& layerName, c
return resultList;
}
theVectorLayer->setRendererV2( theRenderer );
theVectorLayer->setUsingRendererV2( true );
QgsDebugMsg( "Returning the vectorlayer" );
setOpacityForLayer( userLayerElement, theVectorLayer );
resultList.push_back( theVectorLayer );
@ -1389,7 +1387,6 @@ QgsVectorLayer* QgsSLDParser::contourLayerFromRaster( const QDomElement& userSty
//create renderer
QgsFeatureRendererV2* theRenderer = rendererFromUserStyle( userStyleElem, contourLayer );
contourLayer->setRendererV2( theRenderer );
contourLayer->setUsingRendererV2( true );
//add labelling if requested
labelSettingsFromUserStyle( userStyleElem, contourLayer );

22
src/mapserver/qgswmsserver.cpp
View File

@ -1291,15 +1291,13 @@ int QgsWMSServer::featureInfoFromVectorLayer( QgsVectorLayer* layer,
break;
}
//check if feature is rendered at all
if ( layer->isUsingRendererV2() )
{
QgsFeatureRendererV2* r2 = layer->rendererV2();
if ( !r2 )
{
continue;
}
//check if feature is rendered at all
r2->startRender( renderContext, layer );
bool renderV2 = r2->willRenderFeature( feature );
r2->stopRender( renderContext );
@ -1307,15 +1305,6 @@ int QgsWMSServer::featureInfoFromVectorLayer( QgsVectorLayer* layer,
{
continue;
}
}
else
{
QgsRenderer* r = const_cast<QgsRenderer*>( layer->renderer() ); //bad, 'willRenderFeature' should be const
if ( !r || !r->willRenderFeature( &feature ) )
{
continue;
}
}
QDomElement featureElement = infoDocument.createElement( "Feature" );
featureElement.setAttribute( "id", FID_TO_STRING( feature.id() ) );
@ -2114,8 +2103,7 @@ void QgsWMSServer::applyOpacities( const QStringList& layerList, QList< QPair< Q
if ( ml->type() == QgsMapLayer::VectorLayer )
{
QgsVectorLayer* vl = qobject_cast<QgsVectorLayer*>( ml );
if ( vl && vl->isUsingRendererV2() )
{
QgsFeatureRendererV2* rendererV2 = vl->rendererV2();
//backup old renderer
vectorRenderers.push_back( qMakePair( vl, rendererV2->clone() ) );
@ -2126,12 +2114,6 @@ void QgsWMSServer::applyOpacities( const QStringList& layerList, QList< QPair< Q
{
( *symbolIt )->setAlpha(( *symbolIt )->alpha() * opacityRatio );
}
}
else //old symbology
{
vectorOld.push_back( qMakePair( vl, vl->getTransparency() ) );
vl->setTransparency( opacity );
}
//labeling
if ( vl->customProperty( "labeling/enabled" ).toString() == "true" )

64
src/ui/qgsoptionsbase.ui
View File

@ -6,8 +6,8 @@
<rect>
<x>0</x>
<y>0</y>
<width>850</width>
<height>580</height>
<width>848</width>
<height>578</height>
</rect>
</property>
<property name="minimumSize">
@ -266,8 +266,8 @@
<rect>
<x>0</x>
<y>0</y>
<width>654</width>
<height>642</height>
<width>663</width>
<height>564</height>
</rect>
</property>
<layout class="QVBoxLayout" name="verticalLayout_28">
@ -912,8 +912,8 @@
<rect>
<x>0</x>
<y>0</y>
<width>611</width>
<height>808</height>
<width>663</width>
<height>757</height>
</rect>
</property>
<layout class="QVBoxLayout" name="verticalLayout_22">
@ -1248,8 +1248,8 @@
<rect>
<x>0</x>
<y>0</y>
<width>559</width>
<height>417</height>
<width>680</width>
<height>511</height>
</rect>
</property>
<layout class="QVBoxLayout" name="verticalLayout_27">
@ -1567,8 +1567,8 @@
<rect>
<x>0</x>
<y>0</y>
<width>615</width>
<height>781</height>
<width>663</width>
<height>635</height>
</rect>
</property>
<layout class="QVBoxLayout" name="verticalLayout_29">
@ -1668,22 +1668,6 @@
</layout>
</widget>
</item>
<item>
<widget class="QGroupBox" name="groupBox_3">
<property name="title">
<string>Compatibility</string>
</property>
<layout class="QVBoxLayout" name="verticalLayout_9">
<item>
<widget class="QCheckBox" name="chkUseSymbologyNG">
<property name="text">
<string>Use new generation symbology for rendering</string>
</property>
</widget>
</item>
</layout>
</widget>
</item>
<item>
<widget class="QGroupBox" name="groupBox_14">
<property name="title">
@ -2098,8 +2082,8 @@
<rect>
<x>0</x>
<y>0</y>
<width>474</width>
<height>390</height>
<width>452</width>
<height>357</height>
</rect>
</property>
<layout class="QVBoxLayout" name="verticalLayout_25">
@ -2433,8 +2417,8 @@
<rect>
<x>0</x>
<y>0</y>
<width>556</width>
<height>712</height>
<width>491</width>
<height>636</height>
</rect>
</property>
<layout class="QVBoxLayout" name="verticalLayout_30">
@ -2825,8 +2809,8 @@
<rect>
<x>0</x>
<y>0</y>
<width>517</width>
<height>642</height>
<width>442</width>
<height>574</height>
</rect>
</property>
<layout class="QVBoxLayout" name="verticalLayout_31">
@ -3326,8 +3310,8 @@
<rect>
<x>0</x>
<y>0</y>
<width>537</width>
<height>361</height>
<width>426</width>
<height>336</height>
</rect>
</property>
<layout class="QVBoxLayout" name="verticalLayout_6">
@ -3466,8 +3450,8 @@
<rect>
<x>0</x>
<y>0</y>
<width>614</width>
<height>393</height>
<width>582</width>
<height>352</height>
</rect>
</property>
<layout class="QGridLayout" name="gridLayout_15">
@ -3647,8 +3631,8 @@
<rect>
<x>0</x>
<y>0</y>
<width>300</width>
<height>248</height>
<width>268</width>
<height>207</height>
</rect>
</property>
<layout class="QVBoxLayout" name="verticalLayout_32">
@ -3747,8 +3731,8 @@
<rect>
<x>0</x>
<y>0</y>
<width>521</width>
<height>650</height>
<width>663</width>
<height>553</height>
</rect>
</property>
<layout class="QVBoxLayout" name="verticalLayout_33">