← Back to branch summary

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

« back to all changes in this revision

Viewing changes to python/core/symbology-ng-core.sip

  • 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:
python/core/symbology-ng-core.sip
 
1
 
 
2
typedef QList<QgsSymbolV2*> QgsSymbolV2List;
 
3
 
 
4
typedef QList< QPair<QString, QPixmap> > QgsLegendSymbologyList;
 
5
 
 
6
///////////////
 
7
 
 
8
/*
 
9
class QgsSymbolV2LevelItem
 
10
{
 
11
%TypeHeaderCode
 
12
#include <qgsrendererv2.h>
 
13
%End
 
14
 
 
15
public:
 
16
  QgsSymbolV2LevelItem( QgsSymbolV2* symbol, int layer );
 
17
  QgsSymbolV2* symbol();
 
18
  int layer();
 
19
};
 
20
 
 
21
// every level has list of items: symbol + symbol layer num
 
22
typedef QList< QgsSymbolV2LevelItem > QgsSymbolV2Level;
 
23
 
 
24
// this is a list of levels
 
25
typedef QList< QgsSymbolV2Level > QgsSymbolV2LevelOrder;
 
26
*/
 
27
 
 
28
///////////////
 
29
 
 
30
 
 
31
class QgsFeatureRendererV2
 
32
{
 
33
%TypeHeaderCode
 
34
#include <qgsrendererv2.h>
 
35
%End
 
36
 
 
37
 
 
38
%ConvertToSubClassCode
 
39
  if (sipCpp->type() == "singleSymbol")
 
40
    sipClass = sipClass_QgsSingleSymbolRendererV2;
 
41
  else if (sipCpp->type() == "categorizedSymbol")
 
42
    sipClass = sipClass_QgsCategorizedSymbolRendererV2;
 
43
  else if (sipCpp->type() == "graduatedSymbol")
 
44
    sipClass = sipClass_QgsGraduatedSymbolRendererV2;
 
45
  else
 
46
    sipClass = 0;
 
47
%End
 
48
 
 
49
 
 
50
public:
 
51
 
 
52
  //! return a new renderer - used by default in vector layers
 
53
  static QgsFeatureRendererV2* defaultRenderer(QGis::GeometryType geomType) /Factory/;
 
54
 
 
55
  QString type() const;
 
56
 
 
57
  virtual QgsSymbolV2* symbolForFeature(QgsFeature& feature)=0;
 
58
 
 
59
  virtual void startRender(QgsRenderContext& context, const QgsVectorLayer * )=0;
 
60
 
 
61
  virtual void stopRender(QgsRenderContext& context)=0;
 
62
 
 
63
  virtual QList<QString> usedAttributes()=0;
 
64
 
 
65
  virtual ~QgsFeatureRendererV2();
 
66
 
 
67
  virtual QString dump();
 
68
 
 
69
  virtual QgsFeatureRendererV2* clone()=0 /Factory/;
 
70
 
 
71
  virtual QgsSymbolV2List symbols()=0;
 
72
 
 
73
  void renderFeature(QgsFeature& feature, QgsRenderContext& context, int layer = -1, bool drawVertexMarker = false );
 
74
 
 
75
  bool usingSymbolLevels() const;
 
76
  void setUsingSymbolLevels(bool usingSymbolLevels);
 
77
 
 
78
  //! create a renderer from XML element
 
79
  static QgsFeatureRendererV2* load(QDomElement& symbologyElem);
 
80
 
 
81
  //! store renderer info to XML element
 
82
  virtual QDomElement save(QDomDocument& doc);
 
83
 
 
84
  //! return a list of symbology items for the legend
 
85
  virtual QgsLegendSymbologyList legendSymbologyItems(QSize iconSize);
 
86
 
 
87
  //! set type and size of editing vertex markers for subsequent rendering
 
88
  void setVertexMarkerAppearance( int type, int size );
 
89
 
 
90
protected:
 
91
  QgsFeatureRendererV2(QString type);
 
92
 
 
93
  //! render editing vertex marker at specified point
 
94
  void renderVertexMarker( QPointF& pt, QgsRenderContext& context );
 
95
  //! render editing vertex marker for a polyline
 
96
  void renderVertexMarkerPolyline( QPolygonF& pts, QgsRenderContext& context );
 
97
  //! render editing vertex marker for a polygon
 
98
  void renderVertexMarkerPolygon( QPolygonF& pts, QList<QPolygonF>* rings, QgsRenderContext& context );
 
99
 
 
100
};
 
101
 
 
102
///////////////
 
103
 
 
104
class QgsSingleSymbolRendererV2 : QgsFeatureRendererV2
 
105
{
 
106
%TypeHeaderCode
 
107
#include <qgssinglesymbolrendererv2.h>
 
108
%End
 
109
 
 
110
public:
 
111
 
 
112
  QgsSingleSymbolRendererV2(QgsSymbolV2* symbol /Transfer/);
 
113
 
 
114
  virtual ~QgsSingleSymbolRendererV2();
 
115
 
 
116
  virtual QgsSymbolV2* symbolForFeature(QgsFeature& feature);
 
117
 
 
118
  virtual void startRender(QgsRenderContext& context, const QgsVectorLayer * );
 
119
 
 
120
  virtual void stopRender(QgsRenderContext& context);
 
121
 
 
122
  virtual QList<QString> usedAttributes();
 
123
 
 
124
  QgsSymbolV2* symbol() const;
 
125
  void setSymbol(QgsSymbolV2* s /Transfer/);
 
126
 
 
127
  virtual QString dump();
 
128
 
 
129
  virtual QgsFeatureRendererV2* clone() /Factory/;
 
130
 
 
131
  //! create a renderer from XML element
 
132
  static QgsFeatureRendererV2* load(QDomElement& symbologyElem) /Factory/;
 
133
 
 
134
  //! store renderer info to XML element
 
135
  virtual QDomElement save(QDomDocument& doc);
 
136
 
 
137
  //! return a list of symbology items for the legend
 
138
  virtual QgsLegendSymbologyList legendSymbologyItems(QSize iconSize);
 
139
 
 
140
};
 
141
 
 
142
//////////
 
143
 
 
144
class QgsRendererCategoryV2
 
145
{
 
146
%TypeHeaderCode
 
147
#include <qgscategorizedsymbolrendererv2.h>
 
148
%End
 
149
 
 
150
public:
 
151
 
 
152
  //! takes ownership of symbol
 
153
  QgsRendererCategoryV2(QVariant value, QgsSymbolV2* symbol /Transfer/, QString label);
 
154
 
 
155
  QgsRendererCategoryV2(const QgsRendererCategoryV2& cat);
 
156
 
 
157
  ~QgsRendererCategoryV2();
 
158
 
 
159
  QVariant value() const;
 
160
  QgsSymbolV2* symbol();
 
161
  QString label() const;
 
162
 
 
163
  void setSymbol(QgsSymbolV2* s /Transfer/);
 
164
  void setLabel(QString label);
 
165
 
 
166
  QString dump();
 
167
};
 
168
 
 
169
typedef QList<QgsRendererCategoryV2> QgsCategoryList;
 
170
 
 
171
class QgsCategorizedSymbolRendererV2 : QgsFeatureRendererV2
 
172
{
 
173
%TypeHeaderCode
 
174
#include <qgscategorizedsymbolrendererv2.h>
 
175
%End
 
176
 
 
177
public:
 
178
 
 
179
  QgsCategorizedSymbolRendererV2(QString attrName = QString(), QgsCategoryList categories = QgsCategoryList());
 
180
 
 
181
  virtual ~QgsCategorizedSymbolRendererV2();
 
182
 
 
183
  virtual QgsSymbolV2* symbolForFeature(QgsFeature& feature);
 
184
 
 
185
  virtual void startRender(QgsRenderContext& context, const QgsVectorLayer * );
 
186
 
 
187
  virtual void stopRender(QgsRenderContext& context);
 
188
 
 
189
  virtual QList<QString> usedAttributes();
 
190
 
 
191
  virtual QString dump();
 
192
 
 
193
  virtual QgsFeatureRendererV2* clone() /Factory/;
 
194
 
 
195
  const QgsCategoryList& categories();
 
196
 
 
197
  //! return index of category with specified value (-1 if not found)
 
198
  int categoryIndexForValue(QVariant val);
 
199
 
 
200
  bool updateCategorySymbol(int catIndex, QgsSymbolV2* symbol /Transfer/);
 
201
  bool updateCategoryLabel(int catIndex, QString label);
 
202
 
 
203
  bool deleteCategory(int catIndex);
 
204
  void deleteAllCategories();
 
205
 
 
206
  //! create a renderer from XML element
 
207
  static QgsFeatureRendererV2* load(QDomElement& symbologyElem) /Factory/;
 
208
 
 
209
  //! store renderer info to XML element
 
210
  virtual QDomElement save(QDomDocument& doc);
 
211
 
 
212
  //! return a list of symbology items for the legend
 
213
  virtual QgsLegendSymbologyList legendSymbologyItems(QSize iconSize);
 
214
 
 
215
  QString classAttribute() const;
 
216
  void setClassAttribute(QString attr);
 
217
 
 
218
  QgsSymbolV2* sourceSymbol();
 
219
  void setSourceSymbol(QgsSymbolV2* sym /Transfer/);
 
220
 
 
221
  QgsVectorColorRampV2* sourceColorRamp();
 
222
  void setSourceColorRamp(QgsVectorColorRampV2* ramp /Transfer/);
 
223
 
 
224
protected:
 
225
 
 
226
  QgsSymbolV2* symbolForValue(QVariant value);
 
227
};
 
228
 
 
229
//////////
 
230
 
 
231
class QgsRendererRangeV2
 
232
{
 
233
%TypeHeaderCode
 
234
#include <qgsgraduatedsymbolrendererv2.h>
 
235
%End
 
236
 
 
237
public:
 
238
  QgsRendererRangeV2(double lowerValue, double upperValue, QgsSymbolV2* symbol /Transfer/, QString label);
 
239
  QgsRendererRangeV2(const QgsRendererRangeV2& range);
 
240
 
 
241
  ~QgsRendererRangeV2();
 
242
 
 
243
  double lowerValue() const;
 
244
  double upperValue() const;
 
245
 
 
246
  QgsSymbolV2* symbol() const;
 
247
  QString label() const;
 
248
 
 
249
  void setSymbol(QgsSymbolV2* s /Transfer/);
 
250
  void setLabel(QString label);
 
251
 
 
252
  QString dump();
 
253
};
 
254
 
 
255
typedef QList<QgsRendererRangeV2> QgsRangeList;
 
256
 
 
257
class QgsGraduatedSymbolRendererV2 : QgsFeatureRendererV2
 
258
{
 
259
%TypeHeaderCode
 
260
#include <qgsgraduatedsymbolrendererv2.h>
 
261
%End
 
262
 
 
263
public:
 
264
  QgsGraduatedSymbolRendererV2(QString attrNum = QString(), QgsRangeList ranges = QgsRangeList());
 
265
 
 
266
  virtual ~QgsGraduatedSymbolRendererV2();
 
267
 
 
268
  virtual QgsSymbolV2* symbolForFeature(QgsFeature& feature);
 
269
 
 
270
  virtual void startRender(QgsRenderContext& context, const QgsVectorLayer * );
 
271
 
 
272
  virtual void stopRender(QgsRenderContext& context);
 
273
 
 
274
  virtual QList<QString> usedAttributes();
 
275
 
 
276
  virtual QString dump();
 
277
 
 
278
  virtual QgsFeatureRendererV2* clone() /Factory/;
 
279
 
 
280
  QString classAttribute() const;
 
281
  void setClassAttribute(QString attr);
 
282
 
 
283
  const QgsRangeList& ranges();
 
284
 
 
285
  bool updateRangeSymbol(int rangeIndex, QgsSymbolV2* symbol /Transfer/);
 
286
  bool updateRangeLabel(int rangeIndex, QString label);
 
287
 
 
288
  enum Mode
 
289
  {
 
290
    EqualInterval,
 
291
    Quantile,
 
292
    Custom
 
293
  };
 
294
 
 
295
  Mode mode() const;
 
296
  void setMode(Mode mode);
 
297
 
 
298
  static QgsGraduatedSymbolRendererV2* createRenderer(
 
299
                  QgsVectorLayer* vlayer,
 
300
                  QString attrName,
 
301
                  int classes,
 
302
                  Mode mode,
 
303
                  QgsSymbolV2* symbol,
 
304
                  QgsVectorColorRampV2* ramp);
 
305
 
 
306
  //! create a renderer from XML element
 
307
  static QgsFeatureRendererV2* load(QDomElement& symbologyElem) /Factory/;
 
308
 
 
309
  //! store renderer info to XML element
 
310
  virtual QDomElement save(QDomDocument& doc);
 
311
 
 
312
  //! return a list of symbology items for the legend
 
313
  virtual QgsLegendSymbologyList legendSymbologyItems(QSize iconSize);
 
314
 
 
315
  QgsSymbolV2* sourceSymbol();
 
316
  void setSourceSymbol(QgsSymbolV2* sym /Transfer/);
 
317
 
 
318
  QgsVectorColorRampV2* sourceColorRamp();
 
319
  void setSourceColorRamp(QgsVectorColorRampV2* ramp /Transfer/);
 
320
 
 
321
protected:
 
322
  QgsSymbolV2* symbolForValue(double value);
 
323
};
 
324
 
 
325
//////////
 
326
 
 
327
class QgsSymbolLayerV2
 
328
{
 
329
%TypeHeaderCode
 
330
#include <qgssymbollayerv2.h>
 
331
%End
 
332
 
 
333
%ConvertToSubClassCode
 
334
  switch (sipCpp->type())
 
335
  {
 
336
    case QgsSymbolV2::Marker: sipClass = sipClass_QgsMarkerSymbolLayerV2; break;
 
337
    case QgsSymbolV2::Line: sipClass = sipClass_QgsLineSymbolLayerV2; break;
 
338
    case QgsSymbolV2::Fill: sipClass = sipClass_QgsFillSymbolLayerV2; break;
 
339
    default: sipClass = 0; break;
 
340
  }
 
341
%End
 
342
 
 
343
 
 
344
public:
 
345
 
 
346
  virtual void setColor(const QColor& color);
 
347
  virtual QColor color() const;
 
348
 
 
349
  virtual ~QgsSymbolLayerV2();
 
350
 
 
351
  virtual QString layerType() const = 0;
 
352
 
 
353
  virtual void startRender(QgsRenderContext& context) = 0;
 
354
  virtual void stopRender(QgsRenderContext& context) = 0;
 
355
 
 
356
  virtual QgsSymbolLayerV2* clone() const = 0 /Factory/;
 
357
 
 
358
  virtual QgsStringMap properties() const = 0;
 
359
 
 
360
  virtual void drawPreviewIcon(QPainter* painter, QSize size) = 0;
 
361
 
 
362
  virtual QgsSymbolV2* subSymbol();
 
363
  virtual bool setSubSymbol(QgsSymbolV2* symbol /Transfer/);
 
364
 
 
365
  QgsSymbolV2::SymbolType type() const;
 
366
 
 
367
  void setLocked(bool locked);
 
368
  bool isLocked() const;
 
369
 
 
370
  // used only with rending with symbol levels is turned on (0 = first pass, 1 = second, ...)
 
371
  void setRenderingPass(int renderingPass);
 
372
  int renderingPass() const;
 
373
 
 
374
protected:
 
375
  QgsSymbolLayerV2(QgsSymbolV2::SymbolType type, bool locked = false);
 
376
 
 
377
};
 
378
 
 
379
///////////////
 
380
 
 
381
class QgsMarkerSymbolLayerV2 : QgsSymbolLayerV2
 
382
{
 
383
%TypeHeaderCode
 
384
#include <qgssymbollayerv2.h>
 
385
%End
 
386
 
 
387
public:
 
388
  virtual void renderPoint(const QPointF& point, QgsRenderContext& context) = 0;
 
389
 
 
390
  void drawPreviewIcon(QPainter* painter, QSize size);
 
391
 
 
392
  void setAngle(double angle);
 
393
  double angle() const;
 
394
 
 
395
  void setSize(double size);
 
396
  double size() const;
 
397
 
 
398
protected:
 
399
  QgsMarkerSymbolLayerV2(bool locked = false);
 
400
 
 
401
};
 
402
 
 
403
class QgsLineSymbolLayerV2 : QgsSymbolLayerV2
 
404
{
 
405
%TypeHeaderCode
 
406
#include <qgssymbollayerv2.h>
 
407
%End
 
408
 
 
409
public:
 
410
  virtual void renderPolyline(const QPolygonF& points, QgsRenderContext& context) = 0;
 
411
 
 
412
  void setWidth(double width);
 
413
  double width() const;
 
414
        
 
415
  void drawPreviewIcon(QPainter* painter, QSize size);
 
416
 
 
417
protected:
 
418
  QgsLineSymbolLayerV2(bool locked = false);
 
419
 
 
420
};
 
421
 
 
422
class QgsFillSymbolLayerV2 : QgsSymbolLayerV2
 
423
{
 
424
%TypeHeaderCode
 
425
#include <qgssymbollayerv2.h>
 
426
%End
 
427
 
 
428
public:
 
429
  virtual void renderPolygon(const QPolygonF& points, QList<QPolygonF>* rings, QgsRenderContext& context) = 0;
 
430
 
 
431
  void drawPreviewIcon(QPainter* painter, QSize size);
 
432
 
 
433
protected:
 
434
  QgsFillSymbolLayerV2(bool locked = false);
 
435
};
 
436
 
 
437
 
 
438
///////////////
 
439
 
 
440
 
 
441
typedef QList<QgsSymbolLayerV2*> QgsSymbolLayerV2List;
 
442
 
 
443
class QgsSymbolV2
 
444
{
 
445
%TypeHeaderCode
 
446
#include <qgssymbolv2.h>
 
447
%End
 
448
 
 
449
%ConvertToSubClassCode
 
450
  switch (sipCpp->type())
 
451
  {
 
452
    case QgsSymbolV2::Marker: sipClass = sipClass_QgsMarkerSymbolV2; break;
 
453
    case QgsSymbolV2::Line: sipClass = sipClass_QgsLineSymbolV2; break;
 
454
    case QgsSymbolV2::Fill: sipClass = sipClass_QgsFillSymbolV2; break;
 
455
    default: sipClass = 0; break;
 
456
  }
 
457
%End
 
458
 
 
459
public:
 
460
 
 
461
  enum SymbolType
 
462
  {
 
463
        Marker,
 
464
        Line,
 
465
        Fill
 
466
  };
 
467
 
 
468
  virtual ~QgsSymbolV2();
 
469
 
 
470
  //! return new default symbol for specified geometry type
 
471
  static QgsSymbolV2* defaultSymbol(QGis::GeometryType geomType) /Factory/;
 
472
 
 
473
  SymbolType type() const;
 
474
 
 
475
  // symbol layers handling
 
476
 
 
477
  QgsSymbolLayerV2* symbolLayer(int layer);
 
478
 
 
479
  int symbolLayerCount();
 
480
 
 
481
  //! insert symbol layer to specified index
 
482
  bool insertSymbolLayer(int index, QgsSymbolLayerV2* layer /Transfer/);
 
483
 
 
484
  //! append symbol layer at the end of the list
 
485
  bool appendSymbolLayer(QgsSymbolLayerV2* layer /Transfer/);
 
486
 
 
487
  //! delete symbol layer at specified index
 
488
  bool deleteSymbolLayer(int index);
 
489
 
 
490
  //! remove symbol layer from the list and return pointer to it
 
491
  QgsSymbolLayerV2* takeSymbolLayer(int index) /TransferBack/;
 
492
 
 
493
  //! delete layer at specified index and set a new one
 
494
  bool changeSymbolLayer(int index, QgsSymbolLayerV2* layer /Transfer/);
 
495
 
 
496
 
 
497
  void startRender(QgsRenderContext& context);
 
498
  void stopRender(QgsRenderContext& context);
 
499
 
 
500
  void setColor(const QColor& color);
 
501
  QColor color();
 
502
 
 
503
  void drawPreviewIcon(QPainter* painter, QSize size);
 
504
 
 
505
  QImage bigSymbolPreviewImage();
 
506
 
 
507
  QString dump();
 
508
 
 
509
  virtual QgsSymbolV2* clone() const = 0 /Factory/;
 
510
 
 
511
protected:
 
512
  QgsSymbolV2(SymbolType type, QgsSymbolLayerV2List layers /Transfer/); // can't be instantiated
 
513
 
 
514
};
 
515
 
 
516
//////////
 
517
 
 
518
 
 
519
class QgsMarkerSymbolV2 : QgsSymbolV2
 
520
{
 
521
%TypeHeaderCode
 
522
#include <qgssymbolv2.h>
 
523
%End
 
524
 
 
525
public:
 
526
  QgsMarkerSymbolV2(QgsSymbolLayerV2List layers /Transfer/ = QgsSymbolLayerV2List());
 
527
 
 
528
  void setAngle(double angle);
 
529
  double angle();
 
530
 
 
531
  void setSize(double size);
 
532
  double size();
 
533
 
 
534
  void renderPoint(const QPointF& point, QgsRenderContext& context, int layer = -1);
 
535
 
 
536
  virtual QgsSymbolV2* clone() const /Factory/;
 
537
};
 
538
 
 
539
 
 
540
 
 
541
class QgsLineSymbolV2 : QgsSymbolV2
 
542
{
 
543
%TypeHeaderCode
 
544
#include <qgssymbolv2.h>
 
545
%End
 
546
 
 
547
public:
 
548
  QgsLineSymbolV2(QgsSymbolLayerV2List layers /Transfer/ = QgsSymbolLayerV2List());
 
549
 
 
550
  void setWidth(double width);
 
551
  double width();
 
552
 
 
553
  void renderPolyline(const QPolygonF& points, QgsRenderContext& context, int layer = -1);
 
554
 
 
555
  virtual QgsSymbolV2* clone() const /Factory/;
 
556
};
 
557
 
 
558
 
 
559
 
 
560
class QgsFillSymbolV2 : QgsSymbolV2
 
561
{
 
562
%TypeHeaderCode
 
563
#include <qgssymbolv2.h>
 
564
%End
 
565
 
 
566
public:
 
567
  QgsFillSymbolV2(QgsSymbolLayerV2List layers /Transfer/ = QgsSymbolLayerV2List());
 
568
 
 
569
  void renderPolygon(const QPolygonF& points, QList<QPolygonF>* rings, QgsRenderContext& context, int layer = -1);
 
570
 
 
571
  virtual QgsSymbolV2* clone() const /Factory/;
 
572
};
 
573
 
 
574
//////////
 
575
 
 
576
typedef QMap<QString, QString> QgsStringMap;
 
577
 
 
578
//////////
 
579
 
 
580
class QgsSymbolLayerV2Metadata
 
581
{
 
582
%TypeHeaderCode
 
583
#include <qgssymbollayerv2registry.h>
 
584
%End
 
585
 
 
586
public:
 
587
  /** construct invalid metadata */
 
588
  QgsSymbolLayerV2Metadata();
 
589
 
 
590
  /** construct metadata */
 
591
  // TODO
 
592
  //QgsSymbolLayerV2Metadata(QString name, QgsSymbolV2::SymbolType type,
 
593
  //                         QgsSymbolLayerV2CreateFunc pfCreate,
 
594
  //                         QgsSymbolLayerV2WidgetFunc pfWidget);
 
595
 
 
596
  QString name() const;
 
597
  QgsSymbolV2::SymbolType type();
 
598
  // TODO QgsSymbolLayerV2CreateFunc createFunction() const { return mCreateFunc; }
 
599
  // TODO QgsSymbolLayerV2WidgetFunc widgetFunction() const { return mWidgetFunc; }
 
600
 
 
601
};
 
602
 
 
603
//////////
 
604
 
 
605
class QgsSymbolLayerV2Registry
 
606
{
 
607
%TypeHeaderCode
 
608
#include <qgssymbollayerv2registry.h>
 
609
%End
 
610
 
 
611
public:
 
612
 
 
613
  //! return the single instance of this class (instantiate it if not exists)
 
614
  static QgsSymbolLayerV2Registry* instance();
 
615
 
 
616
  //! return metadata for specified symbol layer
 
617
  QgsSymbolLayerV2Metadata symbolLayerMetadata(QString name) const;
 
618
 
 
619
  //! register a new symbol layer type
 
620
  void addSymbolLayerType(const QgsSymbolLayerV2Metadata& metadata);
 
621
 
 
622
  //! create a new instance of symbol layer given symbol layer name and properties
 
623
  QgsSymbolLayerV2* createSymbolLayer(QString name, const QgsStringMap& properties) const /Factory/;
 
624
 
 
625
  //! return a list of available symbol layers for a specified symbol type
 
626
  QStringList symbolLayersForType(QgsSymbolV2::SymbolType type);
 
627
 
 
628
  //! create a new instance of symbol layer for specified symbol type with default settings
 
629
  static QgsSymbolLayerV2* defaultSymbolLayer(QgsSymbolV2::SymbolType type) /Factory/;
 
630
 
 
631
protected:
 
632
  QgsSymbolLayerV2Registry();
 
633
 
 
634
};
 
635
 
 
636
//////////
 
637
 
 
638
class QgsStyleV2
 
639
{
 
640
%TypeHeaderCode
 
641
#include <qgsstylev2.h>
 
642
%End
 
643
 
 
644
public:
 
645
 
 
646
  QgsStyleV2();
 
647
  ~QgsStyleV2();
 
648
 
 
649
  //! return default application-wide style
 
650
  static QgsStyleV2* defaultStyle();
 
651
 
 
652
  //! remove all contents of the style
 
653
  void clear();
 
654
 
 
655
  //! add symbol to style. takes symbol's ownership
 
656
  bool addSymbol(QString name, QgsSymbolV2* symbol);
 
657
 
 
658
  //! remove symbol from style (and delete it)
 
659
  bool removeSymbol(QString name);
 
660
 
 
661
  //! return a NEW copy of symbol
 
662
  QgsSymbolV2* symbol(QString name);
 
663
 
 
664
  //! return a const pointer to a symbol (doesn't create new instance)
 
665
  const QgsSymbolV2* symbolRef(QString name) const;
 
666
 
 
667
  //! return count of symbols in style
 
668
  int symbolCount();
 
669
 
 
670
  //! return a list of names of symbols
 
671
  QStringList symbolNames();
 
672
 
 
673
 
 
674
  //! add color ramp to style. takes ramp's ownership
 
675
  bool addColorRamp(QString name, QgsVectorColorRampV2* colorRamp);
 
676
 
 
677
  //! remove color ramp from style (and delete it)
 
678
  bool removeColorRamp(QString name);
 
679
 
 
680
  //! return a NEW copy of color ramp
 
681
  QgsVectorColorRampV2* colorRamp(QString name);
 
682
 
 
683
  //! return a const pointer to a symbol (doesn't create new instance)
 
684
  const QgsVectorColorRampV2* colorRampRef(QString name) const;
 
685
 
 
686
  //! return count of color ramps
 
687
  int colorRampCount();
 
688
 
 
689
  //! return a list of names of color ramps
 
690
  QStringList colorRampNames();
 
691
 
 
692
 
 
693
  //! load a file into the style
 
694
  bool load(QString filename);
 
695
 
 
696
  //! save style into a file (will use current filename if empty string is passed)
 
697
  bool save(QString filename = QString());
 
698
 
 
699
  //! return last error from load/save operation
 
700
  QString errorString();
 
701
 
 
702
  //! return current file name of the style
 
703
  QString fileName();
 
704
 
 
705
};
 
706
 
 
707
//////////
 
708
 
 
709
class QgsVectorColorRampV2
 
710
{
 
711
%TypeHeaderCode
 
712
#include <qgsvectorcolorrampv2.h>
 
713
%End
 
714
 
 
715
public:
 
716
  virtual ~QgsVectorColorRampV2();
 
717
 
 
718
  virtual QColor color(double value) const = 0;
 
719
 
 
720
  virtual QString type() const = 0;
 
721
 
 
722
  virtual QgsVectorColorRampV2* clone() const = 0;
 
723
 
 
724
  virtual QgsStringMap properties() const = 0;
 
725
 
 
726
};
 
727
 
 
728
//////////
 
729
 
 
730
class QgsSymbologyV2Conversion
 
731
{
 
732
%TypeHeaderCode
 
733
#include <qgssymbologyv2conversion.h>
 
734
%End
 
735
 
 
736
public:
 
737
 
 
738
  //! return a symbol in new symbology as close as possible to old symbol
 
739
  //! @note not all properties will be preserved
 
740
  static QgsSymbolV2* symbolV1toV2(const QgsSymbol* s) /Factory/;
 
741
 
 
742
  //! return a symbol in old symbology as close as possible to new symbol
 
743
  //! @note not all properties will be preserved
 
744
  static QgsSymbol* symbolV2toV1(QgsSymbolV2* s) /Factory/;
 
745
 
 
746
  //! convert layer from old symbology to new symbology
 
747
  //! @note not all properties will be preserved
 
748
  static void rendererV1toV2(QgsVectorLayer* layer);
 
749
 
 
750
  //! convert layer from new symbology to old symbology
 
751
  //! @note not all properties will be preserved
 
752
  static void rendererV2toV1(QgsVectorLayer* layer);
 
753
 
 
754
};