← Back to branch summary

~ubuntu-branches/ubuntu/wily/qgis/wily

« back to all changes in this revision

Viewing changes to src/core/symbology-ng/qgssymbologyv2conversion.cpp

  • Committer: Bazaar Package Importer
  • Author(s): Johan Van de Wauw
  • Date: 2010-07-11 20:23:24 UTC
  • mfrom: (3.1.4 squeeze)
  • Revision ID: james.westby@ubuntu.com-20100711202324-5ktghxa7hracohmr
Tags: 1.4.0+12730-3ubuntu1
https://launchpad.net/bugs/540941
* Merge from Debian unstable (LP: #540941).
* Fix compilation issues with QT 4.7
* Add build-depends on libqt4-webkit-dev 

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/core/symbology-ng/qgssymbologyv2conversion.cpp
 
1
#include "qgssymbologyv2conversion.h"
 
2
 
 
3
#include "qgssinglesymbolrenderer.h"
 
4
#include "qgsgraduatedsymbolrenderer.h"
 
5
#include "qgsuniquevaluerenderer.h"
 
6
#include "qgssymbol.h"
 
7
#include "qgsvectorlayer.h"
 
8
 
 
9
#include "qgslogger.h"
 
10
 
 
11
#include "qgsmarkersymbollayerv2.h"
 
12
#include "qgslinesymbollayerv2.h"
 
13
#include "qgsfillsymbollayerv2.h"
 
14
#include "qgssinglesymbolrendererv2.h"
 
15
#include "qgsgraduatedsymbolrendererv2.h"
 
16
#include "qgscategorizedsymbolrendererv2.h"
 
17
 
 
18
// some ad-hoc conversions
 
19
#define MM2PIXELS(x) ((x)/0.26)
 
20
#define PIXELS2MM(x) ((x)*0.26)
 
21
 
 
22
 
 
23
QgsSymbolV2* QgsSymbologyV2Conversion::symbolV1toV2( const QgsSymbol* s )
 
24
{
 
25
  switch ( s->type() )
 
26
  {
 
27
    case QGis::Point:
 
28
    {
 
29
      QgsMarkerSymbolLayerV2* sl = NULL;
 
30
      double size = MM2PIXELS( s->pointSize() );
 
31
      double angle = 0; // rotation only from classification field
 
32
      QString symbolName = s->pointSymbolName();
 
33
      if ( symbolName.startsWith( "hard:" ) )
 
34
      {
 
35
        // simple symbol marker
 
36
        QColor color = s->fillColor();
 
37
        QColor borderColor = s->color();
 
38
        QString name = symbolName.mid( 5 );
 
39
        sl = new QgsSimpleMarkerSymbolLayerV2( name, color, borderColor, size, angle );
 
40
      }
 
41
      else
 
42
      {
 
43
        // svg symbol marker
 
44
        QString name = symbolName.mid( 4 );
 
45
        sl = new QgsSvgMarkerSymbolLayerV2( name, size, angle );
 
46
      }
 
47
      QgsSymbolLayerV2List layers;
 
48
      layers.append( sl );
 
49
      return new QgsMarkerSymbolV2( layers );
 
50
    }
 
51
 
 
52
    case QGis::Line:
 
53
    {
 
54
      QColor color = s->color();
 
55
      double width = MM2PIXELS( s->lineWidth() );
 
56
      Qt::PenStyle penStyle = s->pen().style();
 
57
      QgsLineSymbolLayerV2* sl = new QgsSimpleLineSymbolLayerV2( color, width, penStyle );
 
58
 
 
59
      QgsSymbolLayerV2List layers;
 
60
      layers.append( sl );
 
61
      return new QgsLineSymbolV2( layers );
 
62
    }
 
63
 
 
64
    case QGis::Polygon:
 
65
    {
 
66
      QColor color = s->fillColor();
 
67
      QColor borderColor = s->color();
 
68
      Qt::BrushStyle brushStyle = s->brush().style();
 
69
      Qt::PenStyle borderStyle = s->pen().style();
 
70
      double borderWidth = MM2PIXELS( s->lineWidth() );
 
71
      QgsFillSymbolLayerV2* sl = new QgsSimpleFillSymbolLayerV2( color, brushStyle, borderColor, borderStyle, borderWidth );
 
72
 
 
73
      QgsSymbolLayerV2List layers;
 
74
      layers.append( sl );
 
75
      return new QgsFillSymbolV2( layers );
 
76
    }
 
77
 
 
78
    default:
 
79
      return NULL;
 
80
  }
 
81
}
 
82
 
 
83
QgsSymbol* QgsSymbologyV2Conversion::symbolV2toV1( QgsSymbolV2* s )
 
84
{
 
85
  if ( s == NULL || s->symbolLayerCount() == 0 )
 
86
    return NULL;
 
87
 
 
88
  // we will use only the first symbol layer
 
89
  QgsSymbolLayerV2* sl = s->symbolLayer( 0 );
 
90
 
 
91
  switch ( sl->type() )
 
92
  {
 
93
    case QgsSymbolV2::Marker:
 
94
    {
 
95
      QgsMarkerSymbolLayerV2* msl = static_cast<QgsMarkerSymbolLayerV2*>( sl );
 
96
      QgsSymbol* sOld = new QgsSymbol( QGis::Point );
 
97
      sOld->setFillColor( sl->color() );
 
98
      sOld->setFillStyle( Qt::SolidPattern );
 
99
      sOld->setPointSize( PIXELS2MM( msl->size() ) );
 
100
      if ( sl->layerType() == "SimpleMarker" )
 
101
      {
 
102
        QgsSimpleMarkerSymbolLayerV2* smsl = static_cast<QgsSimpleMarkerSymbolLayerV2*>( sl );
 
103
        sOld->setColor( smsl->borderColor() );
 
104
        sOld->setNamedPointSymbol( "hard:" + smsl->name() );
 
105
      }
 
106
      else if ( sl->layerType() == "SvgMarker" )
 
107
      {
 
108
        QgsSvgMarkerSymbolLayerV2* smsl = static_cast<QgsSvgMarkerSymbolLayerV2*>( sl );
 
109
        sOld->setNamedPointSymbol( "svg:" + smsl->path() );
 
110
      }
 
111
      return sOld;
 
112
    }
 
113
    break;
 
114
 
 
115
    case QgsSymbolV2::Line:
 
116
    {
 
117
      QgsLineSymbolLayerV2* lsl = static_cast<QgsLineSymbolLayerV2*>( sl );
 
118
      QgsSymbol* sOld = new QgsSymbol( QGis::Line );
 
119
      sOld->setColor( sl->color() );
 
120
      sOld->setLineWidth( PIXELS2MM( lsl->width() ) );
 
121
      if ( sl->layerType() == "SimpleLine" )
 
122
      {
 
123
        // add specific settings
 
124
        QgsSimpleLineSymbolLayerV2* slsl = static_cast<QgsSimpleLineSymbolLayerV2*>( sl );
 
125
        sOld->setLineStyle( slsl->penStyle() );
 
126
      }
 
127
      return sOld;
 
128
    }
 
129
 
 
130
    case QgsSymbolV2::Fill:
 
131
    {
 
132
      QgsSymbol* sOld = new QgsSymbol( QGis::Polygon );
 
133
      sOld->setFillColor( sl->color() );
 
134
      if ( sl->layerType() == "SimpleFill" )
 
135
      {
 
136
        // add specifc settings
 
137
        QgsSimpleFillSymbolLayerV2* sfsl = static_cast<QgsSimpleFillSymbolLayerV2*>( sl );
 
138
        sOld->setColor( sfsl->borderColor() );
 
139
        sOld->setLineWidth( PIXELS2MM( sfsl->borderWidth() ) );
 
140
        sOld->setLineStyle( sfsl->borderStyle() );
 
141
        sOld->setFillStyle( sfsl->brushStyle() );
 
142
      }
 
143
      return sOld;
 
144
    }
 
145
  }
 
146
 
 
147
  return NULL; // should never get here
 
148
}
 
149
 
 
150
void QgsSymbologyV2Conversion::rendererV1toV2( QgsVectorLayer* layer )
 
151
{
 
152
  if ( layer->isUsingRendererV2() )
 
153
    return;
 
154
 
 
155
  const QgsRenderer* r = layer->renderer();
 
156
  if ( r == NULL )
 
157
    return;
 
158
 
 
159
  QgsFeatureRendererV2* r2final = NULL;
 
160
 
 
161
  QString rtype = r->name();
 
162
  if ( rtype == "Single Symbol" )
 
163
  {
 
164
    const QgsSingleSymbolRenderer* ssr = dynamic_cast<const QgsSingleSymbolRenderer*>( r );
 
165
    if ( ssr == NULL )
 
166
      return;
 
167
    QgsSymbolV2* symbol = symbolV1toV2( ssr->symbol() );
 
168
    QgsSingleSymbolRendererV2* r2 = new QgsSingleSymbolRendererV2( symbol );
 
169
    r2final = r2;
 
170
  }
 
171
  else if ( rtype == "Graduated Symbol" )
 
172
  {
 
173
    const QgsGraduatedSymbolRenderer* gsr = dynamic_cast<const QgsGraduatedSymbolRenderer*>( r );
 
174
    if ( gsr == NULL )
 
175
      return;
 
176
 
 
177
    QString attrName;
 
178
    if ( layer->pendingFields().contains( gsr->classificationField() ) )
 
179
    {
 
180
      attrName = layer->pendingFields()[ gsr->classificationField()].name();
 
181
    }
 
182
 
 
183
    QgsRangeList ranges;
 
184
    foreach( const QgsSymbol* sym, gsr->symbols() )
 
185
    {
 
186
      double lowerValue = sym->lowerValue().toDouble();
 
187
      double upperValue = sym->upperValue().toDouble();
 
188
      QString label = sym->label();
 
189
      if ( label.isEmpty() )
 
190
        label = QString( "%1 - %2" ).arg( lowerValue, -1, 'f', 3 ).arg( upperValue, -1, 'f', 3 );
 
191
      QgsSymbolV2* symbolv2 = symbolV1toV2( sym );
 
192
      ranges.append( QgsRendererRangeV2( lowerValue, upperValue, symbolv2, label ) );
 
193
    }
 
194
 
 
195
    QgsGraduatedSymbolRendererV2* r2 = new QgsGraduatedSymbolRendererV2( attrName, ranges );
 
196
 
 
197
    // find out mode
 
198
    QgsGraduatedSymbolRendererV2::Mode m = QgsGraduatedSymbolRendererV2::Custom;
 
199
    switch ( gsr->mode() )
 
200
    {
 
201
      case QgsGraduatedSymbolRenderer::EqualInterval: m = QgsGraduatedSymbolRendererV2::EqualInterval; break;
 
202
      case QgsGraduatedSymbolRenderer::Quantile: m = QgsGraduatedSymbolRendererV2::Quantile; break;
 
203
      case QgsGraduatedSymbolRenderer::Empty: m = QgsGraduatedSymbolRendererV2::Custom; break;
 
204
    }
 
205
    r2->setMode( m );
 
206
    // source symbol, color ramp not set (unknown)
 
207
    r2final = r2;
 
208
  }
 
209
  else if ( rtype == "Continuous Color" )
 
210
  {
 
211
    // TODO
 
212
  }
 
213
  else if ( rtype == "Unique Value" )
 
214
  {
 
215
    const QgsUniqueValueRenderer* uvr = dynamic_cast<const QgsUniqueValueRenderer*>( r );
 
216
    if ( uvr == NULL )
 
217
      return;
 
218
 
 
219
    QString attrName;
 
220
    if ( layer->pendingFields().contains( uvr->classificationField() ) )
 
221
    {
 
222
      attrName = layer->pendingFields()[ uvr->classificationField()].name();
 
223
    }
 
224
 
 
225
    QgsCategoryList cats;
 
226
    foreach( QgsSymbol* sym, uvr->symbols() )
 
227
    {
 
228
      QVariant value = QVariant( sym->lowerValue() );
 
229
      QString label = sym->label();
 
230
      if ( label.isEmpty() )
 
231
        label = value.toString();
 
232
      QgsSymbolV2* symbolv2 = symbolV1toV2( sym );
 
233
      cats.append( QgsRendererCategoryV2( value, symbolv2, label ) );
 
234
    }
 
235
 
 
236
    QgsCategorizedSymbolRendererV2* r2 = new QgsCategorizedSymbolRendererV2( attrName, cats );
 
237
    // source symbol and color ramp are not set (unknown)
 
238
    r2final = r2;
 
239
  }
 
240
 
 
241
  if ( r2final == NULL )
 
242
  {
 
243
    r2final = QgsFeatureRendererV2::defaultRenderer( layer->geometryType() );
 
244
  }
 
245
 
 
246
  // change of renderers
 
247
  layer->setUsingRendererV2( true );
 
248
  layer->setRendererV2( r2final );
 
249
  layer->setRenderer( NULL );
 
250
}
 
251
 
 
252
void QgsSymbologyV2Conversion::rendererV2toV1( QgsVectorLayer* layer )
 
253
{
 
254
  if ( !layer->isUsingRendererV2() )
 
255
    return;
 
256
 
 
257
  QgsFeatureRendererV2* r2 = layer->rendererV2();
 
258
  if ( r2 == NULL )
 
259
    return;
 
260
 
 
261
  QgsRenderer* rfinal = NULL;
 
262
 
 
263
  QString r2type = r2->type();
 
264
  if ( r2type == "singleSymbol" )
 
265
  {
 
266
    QgsSingleSymbolRendererV2* ssr2 = static_cast<QgsSingleSymbolRendererV2*>( r2 );
 
267
 
 
268
    QgsSingleSymbolRenderer* r = new QgsSingleSymbolRenderer( layer->geometryType() );
 
269
    r->addSymbol( symbolV2toV1( ssr2->symbol() ) );
 
270
    rfinal = r;
 
271
  }
 
272
  else if ( r2type == "graduatedSymbol" )
 
273
  {
 
274
    QgsGraduatedSymbolRendererV2* gsr2 = static_cast<QgsGraduatedSymbolRendererV2*>( r2 );
 
275
 
 
276
    QgsGraduatedSymbolRenderer::Mode m;
 
277
    switch ( gsr2->mode() )
 
278
    {
 
279
      case QgsGraduatedSymbolRendererV2::EqualInterval: m = QgsGraduatedSymbolRenderer::EqualInterval; break;
 
280
      case QgsGraduatedSymbolRendererV2::Quantile: m = QgsGraduatedSymbolRenderer::Quantile; break;
 
281
      default: m = QgsGraduatedSymbolRenderer::Empty; break;
 
282
    }
 
283
 
 
284
    QgsGraduatedSymbolRenderer* r = new QgsGraduatedSymbolRenderer( layer->geometryType(), m );
 
285
 
 
286
    r->setClassificationField( layer->fieldNameIndex( gsr2->classAttribute() ) );
 
287
 
 
288
    foreach( QgsRendererRangeV2 range, gsr2->ranges() )
 
289
    {
 
290
      QgsSymbol* s = symbolV2toV1( range.symbol() );
 
291
      s->setLowerValue( QString::number( range.lowerValue(), 'f', 5 ) );
 
292
      s->setUpperValue( QString::number( range.upperValue(), 'f', 5 ) );
 
293
      s->setLabel( range.label() );
 
294
      r->addSymbol( s );
 
295
    }
 
296
 
 
297
    rfinal = r;
 
298
  }
 
299
  else if ( r2type == "categorizedSymbol" )
 
300
  {
 
301
    QgsCategorizedSymbolRendererV2* csr2 = static_cast<QgsCategorizedSymbolRendererV2*>( r2 );
 
302
 
 
303
    QgsUniqueValueRenderer* r = new QgsUniqueValueRenderer( layer->geometryType() );
 
304
 
 
305
    r->setClassificationField( layer->fieldNameIndex( csr2->classAttribute() ) );
 
306
 
 
307
    foreach( QgsRendererCategoryV2 cat, csr2->categories() )
 
308
    {
 
309
      QgsSymbol* s = symbolV2toV1( cat.symbol() );
 
310
      QString val = cat.value().toString();
 
311
      s->setLowerValue( val );
 
312
      s->setUpperValue( val );
 
313
      r->insertValue( val, s );
 
314
    }
 
315
 
 
316
    rfinal = r;
 
317
  }
 
318
 
 
319
 
 
320
  if ( rfinal == NULL )
 
321
  {
 
322
    rfinal = new QgsSingleSymbolRenderer( layer->geometryType() );
 
323
  }
 
324
 
 
325
  layer->setUsingRendererV2( false );
 
326
  layer->setRendererV2( NULL );
 
327
  layer->setRenderer( rfinal );
 
328
}