QGIS API Documentation  2.13.0-Master
qgsrulebasedrendererv2widget.cpp
Go to the documentation of this file.
1 /***************************************************************************
2  qgsrulebasedrendererv2widget.cpp - Settings widget for rule-based renderer
3  ---------------------
4  begin : May 2010
5  copyright : (C) 2010 by Martin Dobias
6  email : wonder dot sk at gmail dot com
7  ***************************************************************************
8  * *
9  * This program is free software; you can redistribute it and/or modify *
10  * it under the terms of the GNU General Public License as published by *
11  * the Free Software Foundation; either version 2 of the License, or *
12  * (at your option) any later version. *
13  * *
14  ***************************************************************************/
15 
17 
18 #include "qgsrulebasedrendererv2.h"
19 #include "qgssymbollayerv2utils.h"
20 #include "qgssymbolv2.h"
21 #include "qgsvectorlayer.h"
22 #include "qgsapplication.h"
23 #include "qgsexpression.h"
25 #include "qgslogger.h"
26 #include "qstring.h"
28 
29 #include <QKeyEvent>
30 #include <QMenu>
31 #include <QProgressDialog>
32 #include <QSettings>
33 #include <QTreeWidgetItem>
34 #include <QVBoxLayout>
35 #include <QMessageBox>
36 
37 #ifdef ENABLE_MODELTEST
38 #include "modeltest.h"
39 #endif
40 
42 {
43  return new QgsRuleBasedRendererV2Widget( layer, style, renderer );
44 }
45 
47  : QgsRendererV2Widget( layer, style )
48 {
49  mRenderer = nullptr;
50  // try to recognize the previous renderer
51  // (null renderer means "no previous renderer")
52 
53 
54  if ( renderer )
55  {
57  }
58  if ( !mRenderer )
59  {
60  // some default options
62 
63  mRenderer = new QgsRuleBasedRendererV2( symbol );
64  }
65 
66  setupUi( this );
67 
69 #ifdef ENABLE_MODELTEST
70  new ModelTest( mModel, this ); // for model validity checking
71 #endif
72  viewRules->setModel( mModel );
73 
74  mDeleteAction = new QAction( tr( "Remove Rule" ), this );
75  mDeleteAction->setShortcut( QKeySequence( QKeySequence::Delete ) );
76 
77  viewRules->addAction( mDeleteAction );
78  viewRules->addAction( mCopyAction );
79  viewRules->addAction( mPasteAction );
80 
81  mRefineMenu = new QMenu( tr( "Refine current rule" ), btnRefineRule );
82  mRefineMenu->addAction( tr( "Add scales to rule" ), this, SLOT( refineRuleScales() ) );
83  mRefineMenu->addAction( tr( "Add categories to rule" ), this, SLOT( refineRuleCategories() ) );
84  mRefineMenu->addAction( tr( "Add ranges to rule" ), this, SLOT( refineRuleRanges() ) );
85  btnRefineRule->setMenu( mRefineMenu );
87 
88  btnAddRule->setIcon( QIcon( QgsApplication::iconPath( "symbologyAdd.svg" ) ) );
89  btnEditRule->setIcon( QIcon( QgsApplication::iconPath( "symbologyEdit.png" ) ) );
90  btnRemoveRule->setIcon( QIcon( QgsApplication::iconPath( "symbologyRemove.svg" ) ) );
91 
92  connect( viewRules, SIGNAL( doubleClicked( const QModelIndex & ) ), this, SLOT( editRule( const QModelIndex & ) ) );
93 
94  // support for context menu (now handled generically)
95  connect( viewRules, SIGNAL( customContextMenuRequested( const QPoint& ) ), this, SLOT( contextMenuViewCategories( const QPoint& ) ) );
96 
97  connect( viewRules->selectionModel(), SIGNAL( currentChanged( QModelIndex, QModelIndex ) ), this, SLOT( currentRuleChanged( QModelIndex, QModelIndex ) ) );
98  connect( viewRules->selectionModel(), SIGNAL( selectionChanged( QItemSelection, QItemSelection ) ), this, SLOT( selectedRulesChanged() ) );
99 
100  connect( btnAddRule, SIGNAL( clicked() ), this, SLOT( addRule() ) );
101  connect( btnEditRule, SIGNAL( clicked() ), this, SLOT( editRule() ) );
102  connect( btnRemoveRule, SIGNAL( clicked() ), this, SLOT( removeRule() ) );
103  connect( mDeleteAction, SIGNAL( triggered() ), this, SLOT( removeRule() ) );
104  connect( btnCountFeatures, SIGNAL( clicked() ), this, SLOT( countFeatures() ) );
105 
106  connect( btnRenderingOrder, SIGNAL( clicked() ), this, SLOT( setRenderingOrder() ) );
107 
110 
111  // store/restore header section widths
112  connect( viewRules->header(), SIGNAL( sectionResized( int, int, int ) ), this, SLOT( saveSectionWidth( int, int, int ) ) );
113 
115 
116 }
117 
119 {
120  qDeleteAll( mCopyBuffer );
121  delete mRenderer;
122 }
123 
125 {
126  return mRenderer;
127 }
128 
130 {
133 
134  QgsRendererRulePropsDialog dlg( newrule, mLayer, mStyle, this, mMapCanvas );
135  if ( dlg.exec() )
136  {
138  if ( current )
139  {
140  // add after this rule
141  QModelIndex currentIndex = viewRules->selectionModel()->currentIndex();
142  mModel->insertRule( currentIndex.parent(), currentIndex.row() + 1, newrule );
143  }
144  else
145  {
146  // append to root rule
147  int rows = mModel->rowCount();
148  mModel->insertRule( QModelIndex(), rows, newrule );
149  }
151  }
152  else
153  {
154  delete newrule;
155  }
156 }
157 
159 {
160  QItemSelectionModel* sel = viewRules->selectionModel();
161  QModelIndex idx = sel->currentIndex();
162  if ( !idx.isValid() )
163  return nullptr;
164  return mModel->ruleForIndex( idx );
165 }
166 
168 {
169  editRule( viewRules->selectionModel()->currentIndex() );
170 }
171 
173 {
174  if ( !index.isValid() )
175  return;
177 
178  QgsRendererRulePropsDialog dlg( rule, mLayer, mStyle, this, mMapCanvas );
179  if ( dlg.exec() )
180  {
181  // model should know about the change and emit dataChanged signal for the view
182  mModel->updateRule( index.parent(), index.row() );
184  }
185 }
186 
188 {
189  QItemSelection sel = viewRules->selectionModel()->selection();
190  QgsDebugMsg( QString( "REMOVE RULES!!! ranges: %1" ).arg( sel.count() ) );
191  Q_FOREACH ( const QItemSelectionRange& range, sel )
192  {
193  QgsDebugMsg( QString( "RANGE: r %1 - %2" ).arg( range.top() ).arg( range.bottom() ) );
194  if ( range.isValid() )
195  mModel->removeRows( range.top(), range.bottom() - range.top() + 1, range.parent() );
196  }
197  // make sure that the selection is gone
198  viewRules->selectionModel()->clear();
200 }
201 
203 {
204  Q_UNUSED( previous );
205  btnEditRule->setEnabled( current.isValid() );
206 }
207 
208 
214 #include <QDialogButtonBox>
215 #include <QInputDialog>
216 #include <QClipboard>
217 
219 {
220  QModelIndexList indexlist = viewRules->selectionModel()->selectedRows();
221 
222  if ( indexlist.isEmpty() )
223  return;
224 
225 
226  if ( type == 0 ) // categories
227  refineRuleCategoriesGui( indexlist );
228  else if ( type == 1 ) // ranges
229  refineRuleRangesGui( indexlist );
230  else // scales
231  refineRuleScalesGui( indexlist );
232 
233  // TODO: set initial rule's symbol to NULL (?)
234 
235  // show the newly added rules
236  Q_FOREACH ( const QModelIndex& index, indexlist )
237  viewRules->expand( index );
238 }
239 
241 {
242  refineRule( 0 );
243 }
244 
246 {
247  refineRule( 1 );
248 }
249 
251 {
252  refineRule( 2 );
253 }
254 
255 void QgsRuleBasedRendererV2Widget::refineRuleCategoriesGui( const QModelIndexList& indexList )
256 {
257  QDialog dlg;
258  dlg.setWindowTitle( tr( "Refine a rule to categories" ) );
259  QVBoxLayout* l = new QVBoxLayout();
261  w->setMapCanvas( mMapCanvas );
262  l->addWidget( w );
263  QDialogButtonBox* bb = new QDialogButtonBox( QDialogButtonBox::Ok | QDialogButtonBox::Cancel );
264  l->addWidget( bb );
265  connect( bb, SIGNAL( accepted() ), &dlg, SLOT( accept() ) );
266  connect( bb, SIGNAL( rejected() ), &dlg, SLOT( reject() ) );
267  dlg.setLayout( l );
268 
269  if ( !dlg.exec() )
270  return;
271 
272  // create new rules
274  Q_FOREACH ( const QModelIndex& index, indexList )
275  {
276  QgsRuleBasedRendererV2::Rule* initialRule = mModel->ruleForIndex( index );
277  mModel->willAddRules( index, r->categories().count() );
279  }
281 }
282 
283 
284 void QgsRuleBasedRendererV2Widget::refineRuleRangesGui( const QModelIndexList& indexList )
285 {
286 
287 
288  QDialog dlg;
289  dlg.setWindowTitle( tr( "Refine a rule to ranges" ) );
290  QVBoxLayout* l = new QVBoxLayout();
292  w->setMapCanvas( mMapCanvas );
293  l->addWidget( w );
294  QDialogButtonBox* bb = new QDialogButtonBox( QDialogButtonBox::Ok | QDialogButtonBox::Cancel );
295  l->addWidget( bb );
296  connect( bb, SIGNAL( accepted() ), &dlg, SLOT( accept() ) );
297  connect( bb, SIGNAL( rejected() ), &dlg, SLOT( reject() ) );
298  dlg.setLayout( l );
299 
300  if ( !dlg.exec() )
301  return;
302 
303  // create new rules
305  Q_FOREACH ( const QModelIndex& index, indexList )
306  {
307  QgsRuleBasedRendererV2::Rule* initialRule = mModel->ruleForIndex( index );
308  mModel->willAddRules( index, r->ranges().count() );
310  }
312 }
313 
314 void QgsRuleBasedRendererV2Widget::refineRuleScalesGui( const QModelIndexList& indexList )
315 {
316  Q_FOREACH ( const QModelIndex& index, indexList )
317  {
318  QgsRuleBasedRendererV2::Rule* initialRule = mModel->ruleForIndex( index );
319 
320  // If any of the rules don't have a symbol let the user know and exit.
321  if ( !initialRule->symbol() )
322  {
323  QMessageBox::warning( this, tr( "Scale refinement" ), tr( "Parent rule %1 must have a symbol for this operation." ).arg( initialRule->label() ) );
324  return;
325  }
326  }
327 
328  QString txt = QInputDialog::getText( this,
329  tr( "Scale refinement" ),
330  tr( "Please enter scale denominators at which will split the rule, separate them by commas (e.g. 1000,5000):" ) );
331  if ( txt.isEmpty() )
332  return;
333 
334  QList<int> scales;
335  bool ok;
336  Q_FOREACH ( const QString& item, txt.split( ',' ) )
337  {
338  int scale = item.toInt( &ok );
339  if ( ok )
340  scales.append( scale );
341  else
342  QMessageBox::information( this, tr( "Error" ), QString( tr( "\"%1\" is not valid scale denominator, ignoring it." ) ).arg( item ) );
343  }
344 
345  Q_FOREACH ( const QModelIndex& index, indexList )
346  {
347  QgsRuleBasedRendererV2::Rule* initialRule = mModel->ruleForIndex( index );
348  mModel->willAddRules( index, scales.count() + 1 );
349  QgsRuleBasedRendererV2::refineRuleScales( initialRule, scales );
350  }
352 }
353 
355 {
356  QList<QgsSymbolV2*> symbolList;
357 
358  if ( !mRenderer )
359  {
360  return symbolList;
361  }
362 
363  QItemSelection sel = viewRules->selectionModel()->selection();
364  Q_FOREACH ( const QItemSelectionRange& range, sel )
365  {
366  QModelIndex parent = range.parent();
367  QgsRuleBasedRendererV2::Rule* parentRule = mModel->ruleForIndex( parent );
369  for ( int row = range.top(); row <= range.bottom(); row++ )
370  {
371  symbolList.append( children[row]->symbol() );
372  }
373  }
374 
375  return symbolList;
376 }
377 
379 {
381  QItemSelection sel = viewRules->selectionModel()->selection();
382  Q_FOREACH ( const QItemSelectionRange& range, sel )
383  {
384  QModelIndex parent = range.parent();
385  QgsRuleBasedRendererV2::Rule* parentRule = mModel->ruleForIndex( parent );
387  for ( int row = range.top(); row <= range.bottom(); row++ )
388  {
389  rl.append( children[row]->clone() );
390  }
391  }
392  return rl;
393 }
394 
396 {
397  // TODO: model/view
398  /*
399  if ( treeRules )
400  {
401  treeRules->populateRules();
402  }
403  */
404 }
405 
407 {
408  if ( !event )
409  {
410  return;
411  }
412 
413  if ( event->key() == Qt::Key_C && event->modifiers() == Qt::ControlModifier )
414  {
415  qDeleteAll( mCopyBuffer );
416  mCopyBuffer.clear();
418  }
419  else if ( event->key() == Qt::Key_V && event->modifiers() == Qt::ControlModifier )
420  {
422  for ( ; rIt != mCopyBuffer.constEnd(); ++rIt )
423  {
424  int rows = mModel->rowCount();
425  mModel->insertRule( QModelIndex(), rows, ( *rIt )->clone() );
426  }
427  }
428 }
429 
430 #include "qgssymbollevelsv2dialog.h"
431 
433 {
435 
436  QgsSymbolLevelsV2Dialog dlg( lst, true, this );
437  dlg.setForceOrderingEnabled( true );
438 
439  dlg.exec();
440 }
441 
442 void QgsRuleBasedRendererV2Widget::saveSectionWidth( int section, int oldSize, int newSize )
443 {
444  Q_UNUSED( oldSize );
445  // skip last section, as it stretches
446  if ( section == 5 )
447  return;
448  QSettings settings;
449  QString path = "/Windows/RuleBasedTree/sectionWidth/" + QString::number( section );
450  settings.setValue( path, newSize );
451 }
452 
454 {
455  QSettings settings;
456  QString path = "/Windows/RuleBasedTree/sectionWidth/";
457  QHeaderView* head = viewRules->header();
458  head->resizeSection( 0, settings.value( path + QString::number( 0 ), 150 ).toInt() );
459  head->resizeSection( 1, settings.value( path + QString::number( 1 ), 150 ).toInt() );
460  head->resizeSection( 2, settings.value( path + QString::number( 2 ), 80 ).toInt() );
461  head->resizeSection( 3, settings.value( path + QString::number( 3 ), 80 ).toInt() );
462  head->resizeSection( 4, settings.value( path + QString::number( 4 ), 50 ).toInt() );
463  head->resizeSection( 5, settings.value( path + QString::number( 5 ), 50 ).toInt() );
464 }
465 
467 {
468  QModelIndexList indexlist = viewRules->selectionModel()->selectedRows();
469  QgsDebugMsg( QString( "%1" ).arg( indexlist.count() ) );
470 
471  if ( indexlist.isEmpty() )
472  return;
473 
474  QMimeData* mime = mModel->mimeData( indexlist );
476 }
477 
479 {
480  const QMimeData* mime = QApplication::clipboard()->mimeData();
481  QModelIndexList indexlist = viewRules->selectionModel()->selectedRows();
483  if ( indexlist.isEmpty() )
484  index = mModel->index( mModel->rowCount(), 0 );
485  else
486  index = indexlist.first();
487  mModel->dropMimeData( mime, Qt::CopyAction, index.row(), index.column(), index.parent() );
488 }
489 
490 
492 {
493  if ( !mLayer || !mRenderer || !mRenderer->rootRule() )
494  {
495  return;
496  }
498 
500  // insert all so that we have counts 0
501  Q_FOREACH ( QgsRuleBasedRendererV2::Rule* rule, ruleList )
502  {
503  countMap[rule].count = 0;
504  countMap[rule].duplicateCount = 0;
505  }
506 
508 
509  QgsRenderContext renderContext;
510  renderContext.setRendererScale( 0 ); // ignore scale
511 
512  QgsExpressionContext context;
516  if ( mMapCanvas )
517  {
520  }
521  else
522  {
524  }
526 
527  renderContext.setExpressionContext( context );
528 
529  mRenderer->startRender( renderContext, mLayer->fields() );
530 
531  int nFeatures = mLayer->featureCount();
532  QProgressDialog p( tr( "Calculating feature count." ), tr( "Abort" ), 0, nFeatures );
533  p.setWindowModality( Qt::WindowModal );
534  int featuresCounted = 0;
535 
536  QgsFeature f;
537  while ( fit.nextFeature( f ) )
538  {
539  renderContext.expressionContext().setFeature( f );
540  QgsRuleBasedRendererV2::RuleList featureRuleList = mRenderer->rootRule()->rulesForFeature( f, &renderContext );
541 
542  Q_FOREACH ( QgsRuleBasedRendererV2::Rule* rule, featureRuleList )
543  {
544  countMap[rule].count++;
545  if ( featureRuleList.size() > 1 )
546  {
547  countMap[rule].duplicateCount++;
548  }
549  Q_FOREACH ( QgsRuleBasedRendererV2::Rule* duplicateRule, featureRuleList )
550  {
551  if ( duplicateRule == rule ) continue;
552  countMap[rule].duplicateCountMap[duplicateRule] += 1;
553  }
554  }
555  ++featuresCounted;
556  if ( featuresCounted % 50 == 0 )
557  {
558  if ( featuresCounted > nFeatures ) //sometimes the feature count is not correct
559  {
560  p.setMaximum( 0 );
561  }
562  p.setValue( featuresCounted );
563  if ( p.wasCanceled() )
564  {
565  return;
566  }
567  }
568  }
569  p.setValue( nFeatures );
570 
571  mRenderer->stopRender( renderContext );
572 
573 #ifdef QGISDEBUG
574  Q_FOREACH ( QgsRuleBasedRendererV2::Rule *rule, countMap.keys() )
575  {
576  QgsDebugMsg( QString( "rule: %1 count %2" ).arg( rule->label() ).arg( countMap[rule].count ) );
577  }
578 #endif
579 
580  mModel->setFeatureCounts( countMap );
581 }
582 
584 {
585  bool enabled = !viewRules->selectionModel()->selectedIndexes().isEmpty();
586  btnRefineRule->setEnabled( enabled );
587  btnRemoveRule->setEnabled( enabled );
588 }
589 
591 
593  : QDialog( parent ), mRule( rule ), mLayer( layer ), mSymbolSelector( nullptr ), mSymbol( nullptr ), mMapCanvas( mapCanvas )
594 {
595  setupUi( this );
596 #ifdef Q_OS_MAC
597  setWindowModality( Qt::WindowModal );
598 #endif
599 
600  connect( buttonBox, SIGNAL( accepted() ), this, SLOT( accept() ) );
601  connect( buttonBox, SIGNAL( rejected() ), this, SLOT( reject() ) );
602 
603  editFilter->setText( mRule->filterExpression() );
604  editFilter->setToolTip( mRule->filterExpression() );
605  editLabel->setText( mRule->label() );
606  editDescription->setText( mRule->description() );
607  editDescription->setToolTip( mRule->description() );
608 
609  if ( mRule->dependsOnScale() )
610  {
611  groupScale->setChecked( true );
612  // caution: rule uses scale denom, scale widget uses true scales
613  if ( rule->scaleMinDenom() > 0 )
614  mScaleRangeWidget->setMaximumScale( 1.0 / rule->scaleMinDenom() );
615  if ( rule->scaleMaxDenom() > 0 )
616  mScaleRangeWidget->setMinimumScale( 1.0 / rule->scaleMaxDenom() );
617  }
618  mScaleRangeWidget->setMapCanvas( mMapCanvas );
619 
620  if ( mRule->symbol() )
621  {
622  groupSymbol->setChecked( true );
623  mSymbol = mRule->symbol()->clone(); // use a clone!
624  }
625  else
626  {
627  groupSymbol->setChecked( false );
629  }
630 
631  mSymbolSelector = new QgsSymbolV2SelectorDialog( mSymbol, style, mLayer, this, true );
632  mSymbolSelector->setMapCanvas( mMapCanvas );
633  QVBoxLayout* l = new QVBoxLayout;
634  l->addWidget( mSymbolSelector );
635  groupSymbol->setLayout( l );
636 
637  connect( btnExpressionBuilder, SIGNAL( clicked() ), this, SLOT( buildExpression() ) );
638  connect( btnTestFilter, SIGNAL( clicked() ), this, SLOT( testFilter() ) );
639 
640  QSettings settings;
641  restoreGeometry( settings.value( "/Windows/QgsRendererRulePropsDialog/geometry" ).toByteArray() );
642 }
643 
645 {
646  delete mSymbol;
647  QSettings settings;
648  settings.setValue( "/Windows/QgsRendererRulePropsDialog/geometry", saveGeometry() );
649 }
650 
652 {
653  QgsExpressionContext context;
657  if ( mMapCanvas )
658  {
661  }
662  else
663  {
665  }
667 
668  QgsExpressionBuilderDialog dlg( mLayer, editFilter->text(), this, "generic", context );
669 
670  if ( dlg.exec() )
671  editFilter->setText( dlg.expressionText() );
672 }
673 
675 {
676  QgsExpression filter( editFilter->text() );
677  if ( filter.hasParserError() )
678  {
679  QMessageBox::critical( this, tr( "Error" ), tr( "Filter expression parsing error:\n" ) + filter.parserErrorString() );
680  return;
681  }
682 
683  QgsExpressionContext context;
687  if ( mMapCanvas )
688  {
691  }
692  else
693  {
695  }
697 
698  if ( !filter.prepare( &context ) )
699  {
700  QMessageBox::critical( this, tr( "Evaluation error" ), filter.evalErrorString() );
701  return;
702  }
703 
704  QApplication::setOverrideCursor( Qt::WaitCursor );
705 
707 
708  int count = 0;
709  QgsFeature f;
710  while ( fit.nextFeature( f ) )
711  {
712  context.setFeature( f );
713 
714  QVariant value = filter.evaluate( &context );
715  if ( value.toInt() != 0 )
716  count++;
717  if ( filter.hasEvalError() )
718  break;
719  }
720 
722 
723  QMessageBox::information( this, tr( "Filter" ), tr( "Filter returned %n feature(s)", "number of filtered features", count ) );
724 }
725 
727 {
728  mRule->setFilterExpression( editFilter->text() );
729  mRule->setLabel( editLabel->text() );
730  mRule->setDescription( editDescription->text() );
731  // caution: rule uses scale denom, scale widget uses true scales
732  mRule->setScaleMinDenom( groupScale->isChecked() ? mScaleRangeWidget->minimumScaleDenom() : 0 );
733  mRule->setScaleMaxDenom( groupScale->isChecked() ? mScaleRangeWidget->maximumScaleDenom() : 0 );
734  mRule->setSymbol( groupSymbol->isChecked() ? mSymbol->clone() : nullptr );
735 
736  QDialog::accept();
737 }
738 
740 
741 /*
742  setDragEnabled(true);
743  viewport()->setAcceptDrops(true);
744  setDropIndicatorShown(true);
745  setDragDropMode(QAbstractItemView::InternalMove);
746 */
747 
748 static QString _formatScale( int denom )
749 {
750  if ( denom != 0 )
751  {
752  QString txt = QString( "1:%L1" ).arg( denom );
753  return txt;
754  }
755  else
756  return QString();
757 }
758 
760 
762  : mR( r )
763 {
764 }
765 
767 {
768  if ( !index.isValid() )
769  return Qt::ItemIsDropEnabled;
770 
771  // allow drop only at first column
772  Qt::ItemFlag drop = ( index.column() == 0 ? Qt::ItemIsDropEnabled : Qt::NoItemFlags );
773 
774  Qt::ItemFlag checkable = ( index.column() == 0 ? Qt::ItemIsUserCheckable : Qt::NoItemFlags );
775 
776  return Qt::ItemIsEnabled | Qt::ItemIsSelectable |
777  Qt::ItemIsEditable | checkable |
778  Qt::ItemIsDragEnabled | drop;
779 }
780 
782 {
783  if ( !index.isValid() )
784  return QVariant();
785 
787 
788  if ( role == Qt::DisplayRole || role == Qt::ToolTipRole )
789  {
790  switch ( index.column() )
791  {
792  case 0:
793  return rule->label();
794  case 1:
795  if ( rule->isElse() )
796  {
797  return "ELSE";
798  }
799  else
800  {
801  return rule->filterExpression().isEmpty() ? tr( "(no filter)" ) : rule->filterExpression();
802  }
803  case 2:
804  return rule->dependsOnScale() ? _formatScale( rule->scaleMaxDenom() ) : QVariant();
805  case 3:
806  return rule->dependsOnScale() ? _formatScale( rule->scaleMinDenom() ) : QVariant();
807  case 4:
808  if ( mFeatureCountMap.count( rule ) == 1 )
809  {
810  return QVariant( mFeatureCountMap[rule].count );
811  }
812  return QVariant();
813  case 5:
814  if ( mFeatureCountMap.count( rule ) == 1 )
815  {
816  if ( role == Qt::DisplayRole )
817  {
818  return QVariant( mFeatureCountMap[rule].duplicateCount );
819  }
820  else // tooltip - detailed info about duplicates
821  {
822  if ( mFeatureCountMap[rule].duplicateCount > 0 )
823  {
824  QString tip = "<p style='margin:0px;'><ul>";
825  Q_FOREACH ( QgsRuleBasedRendererV2::Rule* duplicateRule, mFeatureCountMap[rule].duplicateCountMap.keys() )
826  {
827  QString label = duplicateRule->label().replace( '&', "&amp;" ).replace( '>', "&gt;" ).replace( '<', "&lt;" );
828  tip += tr( "<li><nobr>%1 features also in rule %2</nobr></li>" ).arg( mFeatureCountMap[rule].duplicateCountMap[duplicateRule] ).arg( label );
829  }
830  tip += "</ul>";
831  return tip;
832  }
833  else
834  {
835  return 0;
836  }
837  }
838  }
839  return QVariant();
840  default:
841  return QVariant();
842  }
843  }
844  else if ( role == Qt::DecorationRole && index.column() == 0 && rule->symbol() )
845  {
846  return QgsSymbolLayerV2Utils::symbolPreviewIcon( rule->symbol(), QSize( 16, 16 ) );
847  }
848  else if ( role == Qt::TextAlignmentRole )
849  {
850  return ( index.column() == 2 || index.column() == 3 ) ? Qt::AlignRight : Qt::AlignLeft;
851  }
852  else if ( role == Qt::FontRole && index.column() == 1 )
853  {
854  if ( rule->isElse() )
855  {
856  QFont italicFont;
857  italicFont.setItalic( true );
858  return italicFont;
859  }
860  return QVariant();
861  }
862  else if ( role == Qt::EditRole )
863  {
864  switch ( index.column() )
865  {
866  case 0:
867  return rule->label();
868  case 1:
869  return rule->filterExpression();
870  case 2:
871  return rule->scaleMaxDenom();
872  case 3:
873  return rule->scaleMinDenom();
874  default:
875  return QVariant();
876  }
877  }
878  else if ( role == Qt::CheckStateRole )
879  {
880  if ( index.column() != 0 )
881  return QVariant();
882  return rule->active() ? Qt::Checked : Qt::Unchecked;
883  }
884  else
885  return QVariant();
886 }
887 
888 QVariant QgsRuleBasedRendererV2Model::headerData( int section, Qt::Orientation orientation, int role ) const
889 {
890  if ( orientation == Qt::Horizontal && role == Qt::DisplayRole && section >= 0 && section < 7 )
891  {
892  QStringList lst;
893  lst << tr( "Label" ) << tr( "Rule" ) << tr( "Min. scale" ) << tr( "Max. scale" ) << tr( "Count" ) << tr( "Duplicate count" );
894  return lst[section];
895  }
896  else if ( orientation == Qt::Horizontal && role == Qt::ToolTipRole )
897  {
898  if ( section == 4 ) // Count
899  {
900  return tr( "Number of features in this rule." );
901  }
902  else if ( section == 5 ) // Duplicate count
903  {
904  return tr( "Number of features in this rule which are also present in other rule(s)." );
905  }
906  }
907 
908  return QVariant();
909 }
910 
912 {
913  if ( parent.column() > 0 )
914  return 0;
915 
916  QgsRuleBasedRendererV2::Rule* parentRule = ruleForIndex( parent );
917 
918  return parentRule->children().count();
919 }
920 
922 {
923  return 6;
924 }
925 
927 {
928  if ( hasIndex( row, column, parent ) )
929  {
930  QgsRuleBasedRendererV2::Rule* parentRule = ruleForIndex( parent );
931  QgsRuleBasedRendererV2::Rule* childRule = parentRule->children()[row];
932  return createIndex( row, column, childRule );
933  }
934  return QModelIndex();
935 }
936 
938 {
939  if ( !index.isValid() )
940  return QModelIndex();
941 
942  QgsRuleBasedRendererV2::Rule* childRule = ruleForIndex( index );
943  QgsRuleBasedRendererV2::Rule* parentRule = childRule->parent();
944 
945  if ( parentRule == mR->rootRule() )
946  return QModelIndex();
947 
948  // this is right: we need to know row number of our parent (in our grandparent)
949  int row = parentRule->parent()->children().indexOf( parentRule );
950 
951  return createIndex( row, 0, parentRule );
952 }
953 
954 bool QgsRuleBasedRendererV2Model::setData( const QModelIndex & index, const QVariant & value, int role )
955 {
956  if ( !index.isValid() )
957  return false;
958 
960 
961  if ( role == Qt::CheckStateRole )
962  {
963  rule->setActive( value.toInt() == Qt::Checked );
964  emit dataChanged( index, index );
965  return true;
966  }
967 
968  if ( role != Qt::EditRole )
969  return false;
970 
971  switch ( index.column() )
972  {
973  case 0: // label
974  rule->setLabel( value.toString() );
975  break;
976  case 1: // filter
977  rule->setFilterExpression( value.toString() );
978  break;
979  case 2: // scale min
980  rule->setScaleMaxDenom( value.toInt() );
981  break;
982  case 3: // scale max
983  rule->setScaleMinDenom( value.toInt() );
984  break;
985  default:
986  return false;
987  }
988 
989  emit dataChanged( index, index );
990  return true;
991 }
992 
994 {
995  return Qt::MoveAction; // | Qt::CopyAction
996 }
997 
999 {
1000  QStringList types;
1001  types << "application/vnd.text.list";
1002  return types;
1003 }
1004 
1005 QMimeData *QgsRuleBasedRendererV2Model::mimeData( const QModelIndexList &indexes ) const
1006 {
1007  QMimeData *mimeData = new QMimeData();
1008  QByteArray encodedData;
1009 
1010  QDataStream stream( &encodedData, QIODevice::WriteOnly );
1011 
1012  Q_FOREACH ( const QModelIndex &index, indexes )
1013  {
1014  // each item consists of several columns - let's add it with just first one
1015  if ( !index.isValid() || index.column() != 0 )
1016  continue;
1017 
1018  // we use a clone of the existing rule because it has a new unique rule key
1019  // non-unique rule keys would confuse other components using them (e.g. legend)
1020  QgsRuleBasedRendererV2::Rule* rule = ruleForIndex( index )->clone();
1021  QDomDocument doc;
1022  QgsSymbolV2Map symbols;
1023 
1024  QDomElement rootElem = doc.createElement( "rule_mime" );
1025  rootElem.setAttribute( "type", "renderer" ); // for determining whether rules are from renderer or labeling
1026  QDomElement rulesElem = rule->save( doc, symbols );
1027  rootElem.appendChild( rulesElem );
1028  QDomElement symbolsElem = QgsSymbolLayerV2Utils::saveSymbols( symbols, "symbols", doc );
1029  rootElem.appendChild( symbolsElem );
1030  doc.appendChild( rootElem );
1031 
1032  delete rule;
1033 
1034  stream << doc.toString( -1 );
1035  }
1036 
1037  mimeData->setData( "application/vnd.text.list", encodedData );
1038  return mimeData;
1039 }
1040 
1041 
1042 // manipulate DOM before dropping it so that rules are more useful
1044 {
1045  // labeling rules recognize only "description"
1046  if ( ruleElem.hasAttribute( "description" ) )
1047  ruleElem.setAttribute( "label", ruleElem.attribute( "description" ) );
1048 
1049  // run recursively
1050  QDomElement childRuleElem = ruleElem.firstChildElement( "rule" );
1051  while ( !childRuleElem.isNull() )
1052  {
1053  _labeling2rendererRules( childRuleElem );
1054  childRuleElem = childRuleElem.nextSiblingElement( "rule" );
1055  }
1056 }
1057 
1058 
1060  Qt::DropAction action, int row, int column, const QModelIndex &parent )
1061 {
1062  Q_UNUSED( column );
1063 
1064  if ( action == Qt::IgnoreAction )
1065  return true;
1066 
1067  if ( !data->hasFormat( "application/vnd.text.list" ) )
1068  return false;
1069 
1070  if ( parent.column() > 0 )
1071  return false;
1072 
1073  QByteArray encodedData = data->data( "application/vnd.text.list" );
1074  QDataStream stream( &encodedData, QIODevice::ReadOnly );
1075  int rows = 0;
1076 
1077  if ( row == -1 )
1078  {
1079  // the item was dropped at a parent - we may decide where to put the items - let's append them
1080  row = rowCount( parent );
1081  }
1082 
1083  while ( !stream.atEnd() )
1084  {
1085  QString text;
1086  stream >> text;
1087 
1088  QDomDocument doc;
1089  if ( !doc.setContent( text ) )
1090  continue;
1091  QDomElement rootElem = doc.documentElement();
1092  if ( rootElem.tagName() != "rule_mime" )
1093  continue;
1094  if ( rootElem.attribute( "type" ) == "labeling" )
1095  rootElem.appendChild( doc.createElement( "symbols" ) );
1096  QDomElement symbolsElem = rootElem.firstChildElement( "symbols" );
1097  if ( symbolsElem.isNull() )
1098  continue;
1099  QgsSymbolV2Map symbolMap = QgsSymbolLayerV2Utils::loadSymbols( symbolsElem );
1100  QDomElement ruleElem = rootElem.firstChildElement( "rule" );
1101  if ( rootElem.attribute( "type" ) == "labeling" )
1102  _labeling2rendererRules( ruleElem );
1104 
1105  insertRule( parent, row + rows, rule );
1106 
1107  ++rows;
1108  }
1109  return true;
1110 }
1111 
1113 {
1114  if ( index.isValid() )
1115  return static_cast<QgsRuleBasedRendererV2::Rule*>( index.internalPointer() );
1116  return mR->rootRule();
1117 }
1118 
1120 {
1121  QgsRuleBasedRendererV2::Rule* parentRule = ruleForIndex( parent );
1122 
1123  if ( row < 0 || row >= parentRule->children().count() )
1124  return false;
1125 
1126  QgsDebugMsg( QString( "Called: row %1 count %2 parent ~~%3~~" ).arg( row ).arg( count ).arg( parentRule->dump() ) );
1127 
1128  beginRemoveRows( parent, row, row + count - 1 );
1129 
1130  for ( int i = 0; i < count; i++ )
1131  {
1132  if ( row < parentRule->children().count() )
1133  {
1134  //QgsRuleBasedRendererV2::Rule* r = parentRule->children()[row];
1135  parentRule->removeChildAt( row );
1136  //parentRule->takeChildAt( row );
1137  }
1138  else
1139  {
1140  QgsDebugMsg( "trying to remove invalid index - this should not happen!" );
1141  }
1142  }
1143 
1144  endRemoveRows();
1145 
1146  return true;
1147 }
1148 
1149 
1151 {
1152  beginInsertRows( parent, before, before );
1153 
1154  QgsDebugMsg( QString( "insert before %1 rule: %2" ).arg( before ).arg( newrule->dump() ) );
1155 
1156  QgsRuleBasedRendererV2::Rule* parentRule = ruleForIndex( parent );
1157  parentRule->insertChild( before, newrule );
1158 
1159  endInsertRows();
1160 }
1161 
1163 {
1164  emit dataChanged( index( row, 0, parent ),
1165  index( row, columnCount( parent ), parent ) );
1166 }
1167 
1169 {
1170  emit dataChanged( index( 0, 0, idx ),
1171  index( rowCount( idx ) - 1, columnCount( idx ) - 1, idx ) );
1172 
1173  for ( int i = 0; i < rowCount( idx ); i++ )
1174  {
1175  updateRule( index( i, 0, idx ) );
1176  }
1177 }
1178 
1179 
1181 {
1182  if ( !index.isValid() )
1183  return;
1184 
1185  beginRemoveRows( index.parent(), index.row(), index.row() );
1186 
1187  QgsRuleBasedRendererV2::Rule* rule = ruleForIndex( index );
1188  rule->parent()->removeChild( rule );
1189 
1190  endRemoveRows();
1191 }
1192 
1194 {
1195  int row = rowCount( parent ); // only consider appending
1196  beginInsertRows( parent, row, row + count - 1 );
1197 }
1198 
1200 {
1201  emit endInsertRows();
1202 }
1203 
1205 {
1206  mFeatureCountMap = theCountMap;
1207  updateRule( QModelIndex() );
1208 }
1209 
1211 {
1213  updateRule( QModelIndex() );
1214 }
bool hasIndex(int row, int column, const QModelIndex &parent) const
QString dump(int indent=0) const
Dump for debug purpose.
void customContextMenuRequested(const QPoint &pos)
QgsRuleBasedRendererV2Widget(QgsVectorLayer *layer, QgsStyleV2 *style, QgsFeatureRendererV2 *renderer)
QgsRendererRulePropsDialog(QgsRuleBasedRendererV2::Rule *rule, QgsVectorLayer *layer, QgsStyleV2 *style, QWidget *parent=nullptr, QgsMapCanvas *mapCanvas=nullptr)
static QDomElement saveSymbols(QgsSymbolV2Map &symbols, const QString &tagName, QDomDocument &doc)
Class for parsing and evaluation of expressions (formerly called "search strings").
void setLabel(const QString &label)
QString description() const
A human readable description for this rule.
void clear()
Wrapper for iterator of features from vector data provider or vector layer.
static QgsSymbolV2Map loadSymbols(QDomElement &element)
QByteArray toByteArray() const
static unsigned index
void refineRuleScalesGui(const QModelIndexList &index)
QByteArray data(const QString &mimeType) const
void setupUi(QWidget *widget)
QgsSymbolV2SelectorDialog * mSymbolSelector
int bottom() const
virtual void reject()
void keyPressEvent(QKeyEvent *event) override
QgsRuleBasedRendererV2Model * mModel
const QgsCategoryList & categories() const
QModelIndex currentIndex() const
const QMimeData * mimeData(Mode mode) const
QDomNode appendChild(const QDomNode &newChild)
bool dropMimeData(const QMimeData *data, Qt::DropAction action, int row, int column, const QModelIndex &parent) override
void setMaximum(int maximum)
static QgsExpressionContextScope * atlasScope(const QgsAtlasComposition *atlas)
Creates a new scope which contains variables and functions relating to a QgsAtlasComposition.
QString attribute(const QString &name, const QString &defValue) const
void setWindowModality(Qt::WindowModality windowModality)
void setFeature(const QgsFeature &feature)
Convenience function for setting a feature for the context.
#define QgsDebugMsg(str)
Definition: qgslogger.h:33
QgsFields fields() const
Returns the list of fields of this layer.
virtual bool hasFormat(const QString &mimeType) const
void setActive(bool state)
Sets if this rule is active.
QString toString(int indent) const
void setScaleMaxDenom(int scaleMaxDenom)
Set the maximum denominator for which this rule shall apply.
QStringList split(const QString &sep, SplitBehavior behavior, Qt::CaseSensitivity cs) const
virtual QgsSymbolV2 * clone() const =0
QgsFeatureIterator getFeatures(const QgsFeatureRequest &request=QgsFeatureRequest())
Query the provider for features specified in request.
void rejected()
QStyle * style() const
void setRendererScale(double scale)
void setIcon(const QIcon &icon)
static QString iconPath(const QString &iconFile)
Returns path to the desired icon file.
const QObjectList & children() const
virtual QVariant headerData(int section, Qt::Orientation orientation, int role=Qt::DisplayRole) const override
void addAction(QAction *action)
QgsMapCanvas * mMapCanvas
QList< QgsSymbolV2 * > selectedSymbols() override
Subclasses may provide the capability of changing multiple symbols at once by implementing the follow...
void refineRuleCategoriesGui(const QModelIndexList &index)
QgsRuleBasedRendererV2Model(QgsRuleBasedRendererV2 *r)
QDomElement nextSiblingElement(const QString &tagName) const
Qt::DropActions supportedDropActions() const override
Rule * clone() const
clone this rule, return new instance
void accepted()
const QgsMapSettings & mapSettings() const
Get access to properties used for map rendering.
int exec()
QgsRuleBasedRendererV2::RuleList mCopyBuffer
QDomElement documentElement() const
virtual QgsFeatureRendererV2 * renderer() override
return pointer to the renderer (no transfer of ownership)
void updateRule(const QModelIndex &parent, int row)
void saveSectionWidth(int section, int oldSize, int newSize)
The feature class encapsulates a single feature including its id, geometry and a list of field/values...
Definition: qgsfeature.h:187
virtual QgsFeatureRendererV2 * renderer() override
return pointer to the renderer (no transfer of ownership)
void clear()
QgsRuleBasedRendererV2::Rule * currentRule()
bool isElse()
Check if this rule is an ELSE rule.
QString tr(const char *sourceText, const char *disambiguation, int n)
StandardButton information(QWidget *parent, const QString &title, const QString &text, QFlags< QMessageBox::StandardButton > buttons, StandardButton defaultButton)
Map canvas is a class for displaying all GIS data types on a canvas.
Definition: qgsmapcanvas.h:105
void removeChildAt(int i)
delete child rule
int size() const
virtual int rowCount(const QModelIndex &parent=QModelIndex()) const override
The QgsMapSettings class contains configuration for rendering of the map.
int indexOf(const T &value, int from) const
void resizeSection(int logicalIndex, int size)
virtual QgsFeatureRendererV2 * renderer() override
return pointer to the renderer (no transfer of ownership)
long featureCount(QgsSymbolV2 *symbol)
Number of features rendered with specified symbol.
QList< Key > keys() const
void setDescription(const QString &description)
Set a human readable description for this rule.
void setValue(const QString &key, const QVariant &value)
void setValue(int progress)
bool isValid() const
void refineRuleRangesGui(const QModelIndexList &index)
void addWidget(QWidget *widget, int stretch, QFlags< Qt::AlignmentFlag > alignment)
QString number(int n, int base)
static QIcon symbolPreviewIcon(QgsSymbolV2 *symbol, QSize size)
int count(const T &value) const
QgsVectorLayer * mLayer
void append(const T &value)
static void refineRuleCategories(Rule *initialRule, QgsCategorizedSymbolRendererV2 *r)
take a rule and create a list of new rules based on the categories from categorized symbol renderer ...
static QgsExpressionContextScope * globalScope()
Creates a new scope which contains variables and functions relating to the global QGIS context...
void setLayout(QLayout *layout)
int toInt(bool *ok) const
void dataChanged(const QModelIndex &topLeft, const QModelIndex &bottomRight)
bool hasAttribute(const QString &name) const
virtual void stopRender(QgsRenderContext &context) override
Needs to be called when a render cycle has finished to clean up.
QClipboard * clipboard()
virtual Qt::ItemFlags flags(const QModelIndex &index) const override
bool restoreGeometry(const QByteArray &geometry)
static QString _formatScale(int denom)
void setAttribute(const QString &name, const QString &value)
virtual QVariant data(const QModelIndex &index, int role=Qt::DisplayRole) const override
int toInt(bool *ok, int base) const
Expression contexts are used to encapsulate the parameters around which a QgsExpression should be eva...
static Rule * create(QDomElement &ruleElem, QgsSymbolV2Map &symbolMap)
Create a rule from an XML definition.
bool isEmpty() const
const QgsMapCanvas * mapCanvas() const
Returns the map canvas associated with the widget.
void beginRemoveRows(const QModelIndex &parent, int first, int last)
int row() const
This class wraps a request for features to a vector layer (or directly its vector data provider)...
void setOverrideCursor(const QCursor &cursor)
This class keeps data about a rules for rule-based renderer.
void restoreOverrideCursor()
void * internalPointer() const
QModelIndex parent() const
QGis::GeometryType geometryType() const
Returns point, line or polygon.
Single scope for storing variables and functions for use within a QgsExpressionContext.
QMap< QgsRuleBasedRendererV2::Rule *, QgsRuleBasedRendererV2Count > mFeatureCountMap
void setMimeData(QMimeData *src, Mode mode)
QModelIndex parent() const
void removeRule(const QModelIndex &index)
static QgsRendererV2Widget * create(QgsVectorLayer *layer, QgsStyleV2 *style, QgsFeatureRendererV2 *renderer)
bool atEnd() const
static void refineRuleRanges(Rule *initialRule, QgsGraduatedSymbolRendererV2 *r)
take a rule and create a list of new rules based on the ranges from graduated symbol renderer ...
virtual void accept()
void currentRuleChanged(const QModelIndex &current=QModelIndex(), const QModelIndex &previous=QModelIndex())
QString getText(QWidget *parent, const QString &title, const QString &label, QLineEdit::EchoMode mode, const QString &text, bool *ok, QFlags< Qt::WindowType > flags, QFlags< Qt::InputMethodHint > inputMethodHints)
RuleList descendants() const
Returns all children, grand-children, grand-grand-children, grand-gra...
void setFeatureCounts(const QMap< QgsRuleBasedRendererV2::Rule *, QgsRuleBasedRendererV2Count > &theCountMap)
QModelIndex createIndex(int row, int column, void *ptr) const
virtual bool setData(const QModelIndex &index, const QVariant &value, int role=Qt::EditRole) override
int key() const
void setShortcut(const QKeySequence &shortcut)
QgsExpressionContext & expressionContext()
Gets the expression context.
QMimeData * mimeData(const QModelIndexList &indexes) const override
void setItalic(bool enable)
void beginInsertRows(const QModelIndex &parent, int first, int last)
bool isNull() const
void contextMenuViewCategories(QPoint p)
QString & replace(int position, int n, QChar after)
void setForceOrderingEnabled(bool enabled)
QVariant value(const QString &key, const QVariant &defaultValue) const
QStringList mimeTypes() const override
Contains information about the context of a rendering operation.
QString filterExpression() const
A filter that will check if this rule applies.
static QgsExpressionContextScope * mapSettingsScope(const QgsMapSettings &mapSettings)
Creates a new scope which contains variables and functions relating to a QgsMapSettings object...
void insertRule(const QModelIndex &parent, int before, QgsRuleBasedRendererV2::Rule *newrule)
QgsExpressionContextScope & expressionContextScope()
Returns a reference to the expression context scope for the map canvas.
Definition: qgsmapcanvas.h:442
static QgsSymbolV2 * defaultSymbol(QGis::GeometryType geomType)
return new default symbol for specified geometry type
QByteArray saveGeometry() const
typedef DropActions
const QgsRangeList & ranges() const
Rule * parent()
The parent rule.
QAction * addMenu(QMenu *menu)
When drawing a vector layer with rule-based renderer, it goes through the rules and draws features wi...
QgsRuleBasedRendererV2::Rule * ruleForIndex(const QModelIndex &index) const
void setWindowTitle(const QString &)
RuleList rulesForFeature(QgsFeature &feat, QgsRenderContext *context=nullptr)
tell which rules will be used to render the feature
QDomElement firstChildElement(const QString &tagName) const
virtual QModelIndex index(int row, int column, const QModelIndex &parent=QModelIndex()) const override
provide model index for parent&#39;s child item
virtual int columnCount(const QModelIndex &=QModelIndex()) const override
QgsRuleBasedRendererV2::RuleList selectedRules()
virtual void startRender(QgsRenderContext &context, const QgsFields &fields) override
Needs to be called when a new render cycle is started.
RuleList & children()
Return all children rules of this rule.
StandardButton critical(QWidget *parent, const QString &title, const QString &text, QFlags< QMessageBox::StandardButton > buttons, StandardButton defaultButton)
int column() const
Base class for renderer settings widgets.
QgsRuleBasedRendererV2::Rule * mRule
void setSymbol(QgsSymbolV2 *sym)
set a new symbol (or NULL). Deletes old symbol.
StandardButton warning(QWidget *parent, const QString &title, const QString &text, QFlags< QMessageBox::StandardButton > buttons, StandardButton defaultButton)
static QgsRuleBasedRendererV2 * convertFromRenderer(const QgsFeatureRendererV2 *renderer)
creates a QgsRuleBasedRendererV2 from an existing renderer.
QString tagName() const
void _labeling2rendererRules(QDomElement &ruleElem)
void setData(const QString &mimeType, const QByteArray &data)
static QgsExpressionContextScope * projectScope()
Creates a new scope which contains variables and functions relating to the current QGIS project...
bool removeRows(int row, int count, const QModelIndex &parent=QModelIndex()) override
static QgsExpressionContextScope * layerScope(const QgsMapLayer *layer)
Creates a new scope which contains variables and functions relating to a QgsMapLayer.
const_iterator constEnd() const
void insertChild(int i, Rule *rule)
add child rule, take ownership, sets this as parent
void setFilterExpression(const QString &filterExp)
Set the expression used to check if a given feature shall be rendered with this rule.
QDomElement createElement(const QString &tagName)
bool nextFeature(QgsFeature &f)
const_iterator constBegin() const
bool isValid() const
Geometry is not required. It may still be returned if e.g. required for a filter condition.
void setScaleMinDenom(int scaleMinDenom)
Set the minimum denominator for which this rule shall apply.
bool connect(const QObject *sender, const char *signal, const QObject *receiver, const char *method, Qt::ConnectionType type)
QObject * parent() const
Represents a vector layer which manages a vector based data sets.
bool active() const
Returns if this rule is active.
QString arg(qlonglong a, int fieldWidth, int base, const QChar &fillChar) const
QString toString() const
virtual bool event(QEvent *event)
int count(const Key &key) const
A generic dialog for building expression strings.
virtual void setMapCanvas(QgsMapCanvas *canvas)
Sets the map canvas associated with the widget.
virtual QgsLegendSymbolList legendSymbolItems(double scaleDenominator=-1, const QString &rule="") override
return a list of item text / symbol
void willAddRules(const QModelIndex &parent, int count)
QDomElement save(QDomDocument &doc, QgsSymbolV2Map &symbolMap) const
void setExpressionContext(const QgsExpressionContext &context)
Sets the expression context.
bool setContent(const QByteArray &data, bool namespaceProcessing, QString *errorMsg, int *errorLine, int *errorColumn)
static void refineRuleScales(Rule *initialRule, QList< int > scales)
take a rule and create a list of new rules with intervals of scales given by the passed scale denomin...
typedef ItemFlags