00001 #include "qgssymbologyv2conversion.h"
00002
00003 #include "qgssinglesymbolrenderer.h"
00004 #include "qgsgraduatedsymbolrenderer.h"
00005 #include "qgsuniquevaluerenderer.h"
00006 #include "qgssymbol.h"
00007 #include "qgsvectorlayer.h"
00008
00009 #include "qgslogger.h"
00010
00011 #include "qgsmarkersymbollayerv2.h"
00012 #include "qgslinesymbollayerv2.h"
00013 #include "qgsfillsymbollayerv2.h"
00014 #include "qgssinglesymbolrendererv2.h"
00015 #include "qgsgraduatedsymbolrendererv2.h"
00016 #include "qgscategorizedsymbolrendererv2.h"
00017
00018
00019 QgsSymbolV2* QgsSymbologyV2Conversion::symbolV1toV2( const QgsSymbol* s )
00020 {
00021 switch ( s->type() )
00022 {
00023 case QGis::Point:
00024 {
00025 QgsMarkerSymbolLayerV2* sl = NULL;
00026 double size = s->pointSize();
00027 double angle = 0;
00028 QString symbolName = s->pointSymbolName();
00029 if ( symbolName.startsWith( "hard:" ) )
00030 {
00031
00032 QColor color = s->fillColor();
00033 QColor borderColor = s->color();
00034 QString name = symbolName.mid( 5 );
00035 sl = new QgsSimpleMarkerSymbolLayerV2( name, color, borderColor, size, angle );
00036 }
00037 else
00038 {
00039
00040 QString name = symbolName.mid( 4 );
00041 sl = new QgsSvgMarkerSymbolLayerV2( name, size, angle );
00042 }
00043 QgsSymbolLayerV2List layers;
00044 layers.append( sl );
00045 return new QgsMarkerSymbolV2( layers );
00046 }
00047
00048 case QGis::Line:
00049 {
00050 QColor color = s->color();
00051 double width = s->lineWidth();
00052 Qt::PenStyle penStyle = s->pen().style();
00053 QgsLineSymbolLayerV2* sl = new QgsSimpleLineSymbolLayerV2( color, width, penStyle );
00054
00055 QgsSymbolLayerV2List layers;
00056 layers.append( sl );
00057 return new QgsLineSymbolV2( layers );
00058 }
00059
00060 case QGis::Polygon:
00061 {
00062 QColor color = s->fillColor();
00063 QColor borderColor = s->color();
00064 Qt::BrushStyle brushStyle = s->brush().style();
00065 Qt::PenStyle borderStyle = s->pen().style();
00066 double borderWidth = s->lineWidth();
00067 QgsFillSymbolLayerV2* sl = new QgsSimpleFillSymbolLayerV2( color, brushStyle, borderColor, borderStyle, borderWidth );
00068
00069 QgsSymbolLayerV2List layers;
00070 layers.append( sl );
00071 return new QgsFillSymbolV2( layers );
00072 }
00073
00074 default:
00075 return NULL;
00076 }
00077 }
00078
00079 QgsSymbol* QgsSymbologyV2Conversion::symbolV2toV1( QgsSymbolV2* s )
00080 {
00081 if ( s == NULL || s->symbolLayerCount() == 0 )
00082 return NULL;
00083
00084
00085 QgsSymbolLayerV2* sl = s->symbolLayer( 0 );
00086
00087 switch ( sl->type() )
00088 {
00089 case QgsSymbolV2::Marker:
00090 {
00091 QgsMarkerSymbolLayerV2* msl = static_cast<QgsMarkerSymbolLayerV2*>( sl );
00092 QgsSymbol* sOld = new QgsSymbol( QGis::Point );
00093 sOld->setFillColor( sl->color() );
00094 sOld->setFillStyle( Qt::SolidPattern );
00095 sOld->setPointSize( msl->size() );
00096 if ( sl->layerType() == "SimpleMarker" )
00097 {
00098 QgsSimpleMarkerSymbolLayerV2* smsl = static_cast<QgsSimpleMarkerSymbolLayerV2*>( sl );
00099 sOld->setColor( smsl->borderColor() );
00100 sOld->setNamedPointSymbol( "hard:" + smsl->name() );
00101 }
00102 else if ( sl->layerType() == "SvgMarker" )
00103 {
00104 QgsSvgMarkerSymbolLayerV2* smsl = static_cast<QgsSvgMarkerSymbolLayerV2*>( sl );
00105 sOld->setNamedPointSymbol( "svg:" + smsl->path() );
00106 }
00107 return sOld;
00108 }
00109 break;
00110
00111 case QgsSymbolV2::Line:
00112 {
00113 QgsLineSymbolLayerV2* lsl = static_cast<QgsLineSymbolLayerV2*>( sl );
00114 QgsSymbol* sOld = new QgsSymbol( QGis::Line );
00115 sOld->setColor( sl->color() );
00116 sOld->setLineWidth( lsl->width() );
00117 if ( sl->layerType() == "SimpleLine" )
00118 {
00119
00120 QgsSimpleLineSymbolLayerV2* slsl = static_cast<QgsSimpleLineSymbolLayerV2*>( sl );
00121 sOld->setLineStyle( slsl->penStyle() );
00122 }
00123 return sOld;
00124 }
00125
00126 case QgsSymbolV2::Fill:
00127 {
00128 QgsSymbol* sOld = new QgsSymbol( QGis::Polygon );
00129 sOld->setFillColor( sl->color() );
00130 if ( sl->layerType() == "SimpleFill" )
00131 {
00132
00133 QgsSimpleFillSymbolLayerV2* sfsl = static_cast<QgsSimpleFillSymbolLayerV2*>( sl );
00134 sOld->setColor( sfsl->borderColor() );
00135 sOld->setLineWidth( sfsl->borderWidth() );
00136 sOld->setLineStyle( sfsl->borderStyle() );
00137 sOld->setFillStyle( sfsl->brushStyle() );
00138 }
00139 return sOld;
00140 }
00141 }
00142
00143 return NULL;
00144 }
00145
00146 void QgsSymbologyV2Conversion::rendererV1toV2( QgsVectorLayer* layer )
00147 {
00148 if ( layer->isUsingRendererV2() )
00149 return;
00150
00151 const QgsRenderer* r = layer->renderer();
00152 if ( r == NULL )
00153 return;
00154
00155 QgsFeatureRendererV2* r2final = NULL;
00156
00157 QString rtype = r->name();
00158 if ( rtype == "Single Symbol" )
00159 {
00160 const QgsSingleSymbolRenderer* ssr = dynamic_cast<const QgsSingleSymbolRenderer*>( r );
00161 if ( ssr == NULL )
00162 return;
00163 QgsSymbolV2* symbol = symbolV1toV2( ssr->symbol() );
00164 QgsSingleSymbolRendererV2* r2 = new QgsSingleSymbolRendererV2( symbol );
00165 r2final = r2;
00166 }
00167 else if ( rtype == "Graduated Symbol" )
00168 {
00169 const QgsGraduatedSymbolRenderer* gsr = dynamic_cast<const QgsGraduatedSymbolRenderer*>( r );
00170 if ( gsr == NULL )
00171 return;
00172
00173 QString attrName;
00174 if ( layer->pendingFields().contains( gsr->classificationField() ) )
00175 {
00176 attrName = layer->pendingFields()[ gsr->classificationField()].name();
00177 }
00178
00179 QgsRangeList ranges;
00180 foreach( const QgsSymbol* sym, gsr->symbols() )
00181 {
00182 double lowerValue = sym->lowerValue().toDouble();
00183 double upperValue = sym->upperValue().toDouble();
00184 QString label = sym->label();
00185 if ( label.isEmpty() )
00186 label = QString( "%1 - %2" ).arg( lowerValue, -1, 'f', 3 ).arg( upperValue, -1, 'f', 3 );
00187 QgsSymbolV2* symbolv2 = symbolV1toV2( sym );
00188 ranges.append( QgsRendererRangeV2( lowerValue, upperValue, symbolv2, label ) );
00189 }
00190
00191 QgsGraduatedSymbolRendererV2* r2 = new QgsGraduatedSymbolRendererV2( attrName, ranges );
00192
00193
00194 QgsGraduatedSymbolRendererV2::Mode m = QgsGraduatedSymbolRendererV2::Custom;
00195 switch ( gsr->mode() )
00196 {
00197 case QgsGraduatedSymbolRenderer::EqualInterval: m = QgsGraduatedSymbolRendererV2::EqualInterval; break;
00198 case QgsGraduatedSymbolRenderer::Quantile: m = QgsGraduatedSymbolRendererV2::Quantile; break;
00199 case QgsGraduatedSymbolRenderer::Empty: m = QgsGraduatedSymbolRendererV2::Custom; break;
00200 }
00201 r2->setMode( m );
00202
00203 r2final = r2;
00204 }
00205 else if ( rtype == "Continuous Color" )
00206 {
00207
00208 }
00209 else if ( rtype == "Unique Value" )
00210 {
00211 const QgsUniqueValueRenderer* uvr = dynamic_cast<const QgsUniqueValueRenderer*>( r );
00212 if ( uvr == NULL )
00213 return;
00214
00215 QString attrName;
00216 if ( layer->pendingFields().contains( uvr->classificationField() ) )
00217 {
00218 attrName = layer->pendingFields()[ uvr->classificationField()].name();
00219 }
00220
00221 QgsCategoryList cats;
00222 foreach( QgsSymbol* sym, uvr->symbols() )
00223 {
00224 QVariant value = QVariant( sym->lowerValue() );
00225 QString label = sym->label();
00226 if ( label.isEmpty() )
00227 label = value.toString();
00228 QgsSymbolV2* symbolv2 = symbolV1toV2( sym );
00229 cats.append( QgsRendererCategoryV2( value, symbolv2, label ) );
00230 }
00231
00232 QgsCategorizedSymbolRendererV2* r2 = new QgsCategorizedSymbolRendererV2( attrName, cats );
00233
00234 r2final = r2;
00235 }
00236
00237 if ( r2final == NULL )
00238 {
00239 r2final = QgsFeatureRendererV2::defaultRenderer( layer->geometryType() );
00240 }
00241
00242
00243 layer->setUsingRendererV2( true );
00244 layer->setRendererV2( r2final );
00245 layer->setRenderer( NULL );
00246 }
00247
00248 void QgsSymbologyV2Conversion::rendererV2toV1( QgsVectorLayer* layer )
00249 {
00250 if ( !layer->isUsingRendererV2() )
00251 return;
00252
00253 QgsFeatureRendererV2* r2 = layer->rendererV2();
00254 if ( r2 == NULL )
00255 return;
00256
00257 QgsRenderer* rfinal = NULL;
00258
00259 QString r2type = r2->type();
00260 if ( r2type == "singleSymbol" )
00261 {
00262 QgsSingleSymbolRendererV2* ssr2 = static_cast<QgsSingleSymbolRendererV2*>( r2 );
00263
00264 QgsSingleSymbolRenderer* r = new QgsSingleSymbolRenderer( layer->geometryType() );
00265 r->addSymbol( symbolV2toV1( ssr2->symbol() ) );
00266 rfinal = r;
00267 }
00268 else if ( r2type == "graduatedSymbol" )
00269 {
00270 QgsGraduatedSymbolRendererV2* gsr2 = static_cast<QgsGraduatedSymbolRendererV2*>( r2 );
00271
00272 QgsGraduatedSymbolRenderer::Mode m;
00273 switch ( gsr2->mode() )
00274 {
00275 case QgsGraduatedSymbolRendererV2::EqualInterval: m = QgsGraduatedSymbolRenderer::EqualInterval; break;
00276 case QgsGraduatedSymbolRendererV2::Quantile: m = QgsGraduatedSymbolRenderer::Quantile; break;
00277 default: m = QgsGraduatedSymbolRenderer::Empty; break;
00278 }
00279
00280 QgsGraduatedSymbolRenderer* r = new QgsGraduatedSymbolRenderer( layer->geometryType(), m );
00281
00282 r->setClassificationField( layer->fieldNameIndex( gsr2->classAttribute() ) );
00283
00284 foreach( QgsRendererRangeV2 range, gsr2->ranges() )
00285 {
00286 QgsSymbol* s = symbolV2toV1( range.symbol() );
00287 s->setLowerValue( QString::number( range.lowerValue(), 'f', 5 ) );
00288 s->setUpperValue( QString::number( range.upperValue(), 'f', 5 ) );
00289 s->setLabel( range.label() );
00290 r->addSymbol( s );
00291 }
00292
00293 rfinal = r;
00294 }
00295 else if ( r2type == "categorizedSymbol" )
00296 {
00297 QgsCategorizedSymbolRendererV2* csr2 = static_cast<QgsCategorizedSymbolRendererV2*>( r2 );
00298
00299 QgsUniqueValueRenderer* r = new QgsUniqueValueRenderer( layer->geometryType() );
00300
00301 r->setClassificationField( layer->fieldNameIndex( csr2->classAttribute() ) );
00302
00303 foreach( QgsRendererCategoryV2 cat, csr2->categories() )
00304 {
00305 QgsSymbol* s = symbolV2toV1( cat.symbol() );
00306 QString val = cat.value().toString();
00307 s->setLowerValue( val );
00308 s->setUpperValue( val );
00309 r->insertValue( val, s );
00310 }
00311
00312 rfinal = r;
00313 }
00314
00315
00316 if ( rfinal == NULL )
00317 {
00318 rfinal = new QgsSingleSymbolRenderer( layer->geometryType() );
00319 }
00320
00321 layer->setUsingRendererV2( false );
00322 layer->setRendererV2( NULL );
00323 layer->setRenderer( rfinal );
00324 }