QGIS API Documentation  2.15.0-Master (94d88e6)
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 
108  connect( mModel, SIGNAL( dataChanged( QModelIndex, QModelIndex ) ), this, SIGNAL( widgetChanged() ) );
109 
112 
113  // store/restore header section widths
114  connect( viewRules->header(), SIGNAL( sectionResized( int, int, int ) ), this, SLOT( saveSectionWidth( int, int, int ) ) );
115 
117 
118 }
119 
121 {
122  qDeleteAll( mCopyBuffer );
123  delete mRenderer;
124 }
125 
127 {
128  return mRenderer;
129 }
130 
132 {
135 
136  QgsRendererRulePropsDialog dlg( newrule, mLayer, mStyle, this, mMapCanvas );
137  if ( dlg.exec() )
138  {
140  if ( current )
141  {
142  // add after this rule
143  QModelIndex currentIndex = viewRules->selectionModel()->currentIndex();
144  mModel->insertRule( currentIndex.parent(), currentIndex.row() + 1, newrule );
145  }
146  else
147  {
148  // append to root rule
149  int rows = mModel->rowCount();
150  mModel->insertRule( QModelIndex(), rows, newrule );
151  }
153  emit widgetChanged();
154  }
155  else
156  {
157  delete newrule;
158  }
159 }
160 
162 {
163  QItemSelectionModel* sel = viewRules->selectionModel();
164  QModelIndex idx = sel->currentIndex();
165  if ( !idx.isValid() )
166  return nullptr;
167  return mModel->ruleForIndex( idx );
168 }
169 
171 {
172  editRule( viewRules->selectionModel()->currentIndex() );
173 }
174 
176 {
177  if ( !index.isValid() )
178  return;
180 
181  QgsRendererRulePropsDialog dlg( rule, mLayer, mStyle, this, mMapCanvas );
182  if ( dlg.exec() )
183  {
184  // model should know about the change and emit dataChanged signal for the view
185  mModel->updateRule( index.parent(), index.row() );
187  }
188 }
189 
191 {
192  QItemSelection sel = viewRules->selectionModel()->selection();
193  QgsDebugMsg( QString( "REMOVE RULES!!! ranges: %1" ).arg( sel.count() ) );
194  Q_FOREACH ( const QItemSelectionRange& range, sel )
195  {
196  QgsDebugMsg( QString( "RANGE: r %1 - %2" ).arg( range.top() ).arg( range.bottom() ) );
197  if ( range.isValid() )
198  mModel->removeRows( range.top(), range.bottom() - range.top() + 1, range.parent() );
199  }
200  // make sure that the selection is gone
201  viewRules->selectionModel()->clear();
203 }
204 
206 {
207  Q_UNUSED( previous );
208  btnEditRule->setEnabled( current.isValid() );
209 }
210 
211 
217 #include <QDialogButtonBox>
218 #include <QInputDialog>
219 #include <QClipboard>
220 
222 {
223  QModelIndexList indexlist = viewRules->selectionModel()->selectedRows();
224 
225  if ( indexlist.isEmpty() )
226  return;
227 
228 
229  if ( type == 0 ) // categories
230  refineRuleCategoriesGui( indexlist );
231  else if ( type == 1 ) // ranges
232  refineRuleRangesGui( indexlist );
233  else // scales
234  refineRuleScalesGui( indexlist );
235 
236  // TODO: set initial rule's symbol to NULL (?)
237 
238  // show the newly added rules
239  Q_FOREACH ( const QModelIndex& index, indexlist )
240  viewRules->expand( index );
241 }
242 
244 {
245  refineRule( 0 );
246 }
247 
249 {
250  refineRule( 1 );
251 }
252 
254 {
255  refineRule( 2 );
256 }
257 
258 void QgsRuleBasedRendererV2Widget::refineRuleCategoriesGui( const QModelIndexList& indexList )
259 {
260  QDialog dlg;
261  dlg.setWindowTitle( tr( "Refine a rule to categories" ) );
262  QVBoxLayout* l = new QVBoxLayout();
264  w->setMapCanvas( mMapCanvas );
265  l->addWidget( w );
266  QDialogButtonBox* bb = new QDialogButtonBox( QDialogButtonBox::Ok | QDialogButtonBox::Cancel );
267  l->addWidget( bb );
268  connect( bb, SIGNAL( accepted() ), &dlg, SLOT( accept() ) );
269  connect( bb, SIGNAL( rejected() ), &dlg, SLOT( reject() ) );
270  dlg.setLayout( l );
271 
272  if ( !dlg.exec() )
273  return;
274 
275  // create new rules
277  Q_FOREACH ( const QModelIndex& index, indexList )
278  {
279  QgsRuleBasedRendererV2::Rule* initialRule = mModel->ruleForIndex( index );
280  mModel->willAddRules( index, r->categories().count() );
282  }
284 }
285 
286 
287 void QgsRuleBasedRendererV2Widget::refineRuleRangesGui( const QModelIndexList& indexList )
288 {
289 
290 
291  QDialog dlg;
292  dlg.setWindowTitle( tr( "Refine a rule to ranges" ) );
293  QVBoxLayout* l = new QVBoxLayout();
295  w->setMapCanvas( mMapCanvas );
296  l->addWidget( w );
297  QDialogButtonBox* bb = new QDialogButtonBox( QDialogButtonBox::Ok | QDialogButtonBox::Cancel );
298  l->addWidget( bb );
299  connect( bb, SIGNAL( accepted() ), &dlg, SLOT( accept() ) );
300  connect( bb, SIGNAL( rejected() ), &dlg, SLOT( reject() ) );
301  dlg.setLayout( l );
302 
303  if ( !dlg.exec() )
304  return;
305 
306  // create new rules
308  Q_FOREACH ( const QModelIndex& index, indexList )
309  {
310  QgsRuleBasedRendererV2::Rule* initialRule = mModel->ruleForIndex( index );
311  mModel->willAddRules( index, r->ranges().count() );
313  }
315 }
316 
317 void QgsRuleBasedRendererV2Widget::refineRuleScalesGui( const QModelIndexList& indexList )
318 {
319  Q_FOREACH ( const QModelIndex& index, indexList )
320  {
321  QgsRuleBasedRendererV2::Rule* initialRule = mModel->ruleForIndex( index );
322 
323  // If any of the rules don't have a symbol let the user know and exit.
324  if ( !initialRule->symbol() )
325  {
326  QMessageBox::warning( this, tr( "Scale refinement" ), tr( "Parent rule %1 must have a symbol for this operation." ).arg( initialRule->label() ) );
327  return;
328  }
329  }
330 
331  QString txt = QInputDialog::getText( this,
332  tr( "Scale refinement" ),
333  tr( "Please enter scale denominators at which will split the rule, separate them by commas (e.g. 1000,5000):" ) );
334  if ( txt.isEmpty() )
335  return;
336 
337  QList<int> scales;
338  bool ok;
339  Q_FOREACH ( const QString& item, txt.split( ',' ) )
340  {
341  int scale = item.toInt( &ok );
342  if ( ok )
343  scales.append( scale );
344  else
345  QMessageBox::information( this, tr( "Error" ), QString( tr( "\"%1\" is not valid scale denominator, ignoring it." ) ).arg( item ) );
346  }
347 
348  Q_FOREACH ( const QModelIndex& index, indexList )
349  {
350  QgsRuleBasedRendererV2::Rule* initialRule = mModel->ruleForIndex( index );
351  mModel->willAddRules( index, scales.count() + 1 );
352  QgsRuleBasedRendererV2::refineRuleScales( initialRule, scales );
353  }
355 }
356 
358 {
359  QList<QgsSymbolV2*> symbolList;
360 
361  if ( !mRenderer )
362  {
363  return symbolList;
364  }
365 
366  QItemSelection sel = viewRules->selectionModel()->selection();
367  Q_FOREACH ( const QItemSelectionRange& range, sel )
368  {
369  QModelIndex parent = range.parent();
370  QgsRuleBasedRendererV2::Rule* parentRule = mModel->ruleForIndex( parent );
372  for ( int row = range.top(); row <= range.bottom(); row++ )
373  {
374  symbolList.append( children[row]->symbol() );
375  }
376  }
377 
378  return symbolList;
379 }
380 
382 {
384  QItemSelection sel = viewRules->selectionModel()->selection();
385  Q_FOREACH ( const QItemSelectionRange& range, sel )
386  {
387  QModelIndex parent = range.parent();
388  QgsRuleBasedRendererV2::Rule* parentRule = mModel->ruleForIndex( parent );
390  for ( int row = range.top(); row <= range.bottom(); row++ )
391  {
392  rl.append( children[row]->clone() );
393  }
394  }
395  return rl;
396 }
397 
399 {
400  // TODO: model/view
401  /*
402  if ( treeRules )
403  {
404  treeRules->populateRules();
405  }
406  */
407 }
408 
410 {
411  if ( !event )
412  {
413  return;
414  }
415 
416  if ( event->key() == Qt::Key_C && event->modifiers() == Qt::ControlModifier )
417  {
418  qDeleteAll( mCopyBuffer );
419  mCopyBuffer.clear();
421  }
422  else if ( event->key() == Qt::Key_V && event->modifiers() == Qt::ControlModifier )
423  {
425  for ( ; rIt != mCopyBuffer.constEnd(); ++rIt )
426  {
427  int rows = mModel->rowCount();
428  mModel->insertRule( QModelIndex(), rows, ( *rIt )->clone() );
429  }
430  }
431 }
432 
433 #include "qgssymbollevelsv2dialog.h"
434 
436 {
438 
439  QgsSymbolLevelsV2Dialog dlg( lst, true, this );
440  dlg.setForceOrderingEnabled( true );
441 
442  dlg.exec();
443 }
444 
445 void QgsRuleBasedRendererV2Widget::saveSectionWidth( int section, int oldSize, int newSize )
446 {
447  Q_UNUSED( oldSize );
448  // skip last section, as it stretches
449  if ( section == 5 )
450  return;
451  QSettings settings;
452  QString path = "/Windows/RuleBasedTree/sectionWidth/" + QString::number( section );
453  settings.setValue( path, newSize );
454 }
455 
457 {
458  QSettings settings;
459  QString path = "/Windows/RuleBasedTree/sectionWidth/";
460  QHeaderView* head = viewRules->header();
461  head->resizeSection( 0, settings.value( path + QString::number( 0 ), 150 ).toInt() );
462  head->resizeSection( 1, settings.value( path + QString::number( 1 ), 150 ).toInt() );
463  head->resizeSection( 2, settings.value( path + QString::number( 2 ), 80 ).toInt() );
464  head->resizeSection( 3, settings.value( path + QString::number( 3 ), 80 ).toInt() );
465  head->resizeSection( 4, settings.value( path + QString::number( 4 ), 50 ).toInt() );
466  head->resizeSection( 5, settings.value( path + QString::number( 5 ), 50 ).toInt() );
467 }
468 
470 {
471  QModelIndexList indexlist = viewRules->selectionModel()->selectedRows();
472  QgsDebugMsg( QString( "%1" ).arg( indexlist.count() ) );
473 
474  if ( indexlist.isEmpty() )
475  return;
476 
477  QMimeData* mime = mModel->mimeData( indexlist );
479 }
480 
482 {
483  const QMimeData* mime = QApplication::clipboard()->mimeData();
484  QModelIndexList indexlist = viewRules->selectionModel()->selectedRows();
486  if ( indexlist.isEmpty() )
487  index = mModel->index( mModel->rowCount(), 0 );
488  else
489  index = indexlist.first();
490  mModel->dropMimeData( mime, Qt::CopyAction, index.row(), index.column(), index.parent() );
491 }
492 
493 
495 {
496  if ( !mLayer || !mRenderer || !mRenderer->rootRule() )
497  {
498  return;
499  }
501 
503  // insert all so that we have counts 0
504  Q_FOREACH ( QgsRuleBasedRendererV2::Rule* rule, ruleList )
505  {
506  countMap[rule].count = 0;
507  countMap[rule].duplicateCount = 0;
508  }
509 
511 
512  QgsRenderContext renderContext;
513  renderContext.setRendererScale( 0 ); // ignore scale
514 
515  QgsExpressionContext context;
519  if ( mMapCanvas )
520  {
523  }
524  else
525  {
527  }
529 
530  renderContext.setExpressionContext( context );
531 
532  mRenderer->startRender( renderContext, mLayer->fields() );
533 
534  int nFeatures = mLayer->featureCount();
535  QProgressDialog p( tr( "Calculating feature count." ), tr( "Abort" ), 0, nFeatures );
536  p.setWindowModality( Qt::WindowModal );
537  int featuresCounted = 0;
538 
539  QgsFeature f;
540  while ( fit.nextFeature( f ) )
541  {
542  renderContext.expressionContext().setFeature( f );
543  QgsRuleBasedRendererV2::RuleList featureRuleList = mRenderer->rootRule()->rulesForFeature( f, &renderContext );
544 
545  Q_FOREACH ( QgsRuleBasedRendererV2::Rule* rule, featureRuleList )
546  {
547  countMap[rule].count++;
548  if ( featureRuleList.size() > 1 )
549  {
550  countMap[rule].duplicateCount++;
551  }
552  Q_FOREACH ( QgsRuleBasedRendererV2::Rule* duplicateRule, featureRuleList )
553  {
554  if ( duplicateRule == rule ) continue;
555  countMap[rule].duplicateCountMap[duplicateRule] += 1;
556  }
557  }
558  ++featuresCounted;
559  if ( featuresCounted % 50 == 0 )
560  {
561  if ( featuresCounted > nFeatures ) //sometimes the feature count is not correct
562  {
563  p.setMaximum( 0 );
564  }
565  p.setValue( featuresCounted );
566  if ( p.wasCanceled() )
567  {
568  return;
569  }
570  }
571  }
572  p.setValue( nFeatures );
573 
574  mRenderer->stopRender( renderContext );
575 
576 #ifdef QGISDEBUG
577  Q_FOREACH ( QgsRuleBasedRendererV2::Rule *rule, countMap.keys() )
578  {
579  QgsDebugMsg( QString( "rule: %1 count %2" ).arg( rule->label() ).arg( countMap[rule].count ) );
580  }
581 #endif
582 
583  mModel->setFeatureCounts( countMap );
584 }
585 
587 {
588  bool enabled = !viewRules->selectionModel()->selectedIndexes().isEmpty();
589  btnRefineRule->setEnabled( enabled );
590  btnRemoveRule->setEnabled( enabled );
591 }
592 
594 
596  : QDialog( parent )
597  , mRule( rule )
598  , mLayer( layer )
599  , mSymbolSelector( nullptr )
600  , mSymbol( nullptr )
601  , mMapCanvas( mapCanvas )
602 {
603  setupUi( this );
604 #ifdef Q_OS_MAC
605  setWindowModality( Qt::WindowModal );
606 #endif
607 
608  connect( buttonBox, SIGNAL( accepted() ), this, SLOT( accept() ) );
609  connect( buttonBox, SIGNAL( rejected() ), this, SLOT( reject() ) );
610 
611  editFilter->setText( mRule->filterExpression() );
612  editFilter->setToolTip( mRule->filterExpression() );
613  editLabel->setText( mRule->label() );
614  editDescription->setText( mRule->description() );
615  editDescription->setToolTip( mRule->description() );
616 
617  if ( mRule->dependsOnScale() )
618  {
619  groupScale->setChecked( true );
620  // caution: rule uses scale denom, scale widget uses true scales
621  if ( rule->scaleMinDenom() > 0 )
622  mScaleRangeWidget->setMaximumScale( 1.0 / rule->scaleMinDenom() );
623  if ( rule->scaleMaxDenom() > 0 )
624  mScaleRangeWidget->setMinimumScale( 1.0 / rule->scaleMaxDenom() );
625  }
626  mScaleRangeWidget->setMapCanvas( mMapCanvas );
627 
628  if ( mRule->symbol() )
629  {
630  groupSymbol->setChecked( true );
631  mSymbol = mRule->symbol()->clone(); // use a clone!
632  }
633  else
634  {
635  groupSymbol->setChecked( false );
637  }
638 
639  mSymbolSelector = new QgsSymbolV2SelectorDialog( mSymbol, style, mLayer, this, true );
640  mSymbolSelector->setMapCanvas( mMapCanvas );
641  QVBoxLayout* l = new QVBoxLayout;
642  l->addWidget( mSymbolSelector );
643  groupSymbol->setLayout( l );
644 
645  connect( btnExpressionBuilder, SIGNAL( clicked() ), this, SLOT( buildExpression() ) );
646  connect( btnTestFilter, SIGNAL( clicked() ), this, SLOT( testFilter() ) );
647 
648  QSettings settings;
649  restoreGeometry( settings.value( "/Windows/QgsRendererRulePropsDialog/geometry" ).toByteArray() );
650 }
651 
653 {
654  delete mSymbol;
655  QSettings settings;
656  settings.setValue( "/Windows/QgsRendererRulePropsDialog/geometry", saveGeometry() );
657 }
658 
660 {
661  QgsExpressionContext context;
665  if ( mMapCanvas )
666  {
669  }
670  else
671  {
673  }
675 
676  QgsExpressionBuilderDialog dlg( mLayer, editFilter->text(), this, "generic", context );
677 
678  if ( dlg.exec() )
679  editFilter->setText( dlg.expressionText() );
680 }
681 
683 {
684  QgsExpression filter( editFilter->text() );
685  if ( filter.hasParserError() )
686  {
687  QMessageBox::critical( this, tr( "Error" ), tr( "Filter expression parsing error:\n" ) + filter.parserErrorString() );
688  return;
689  }
690 
691  QgsExpressionContext context;
695  if ( mMapCanvas )
696  {
699  }
700  else
701  {
703  }
705 
706  if ( !filter.prepare( &context ) )
707  {
708  QMessageBox::critical( this, tr( "Evaluation error" ), filter.evalErrorString() );
709  return;
710  }
711 
712  QApplication::setOverrideCursor( Qt::WaitCursor );
713 
715 
716  int count = 0;
717  QgsFeature f;
718  while ( fit.nextFeature( f ) )
719  {
720  context.setFeature( f );
721 
722  QVariant value = filter.evaluate( &context );
723  if ( value.toInt() != 0 )
724  count++;
725  if ( filter.hasEvalError() )
726  break;
727  }
728 
730 
731  QMessageBox::information( this, tr( "Filter" ), tr( "Filter returned %n feature(s)", "number of filtered features", count ) );
732 }
733 
735 {
736  mRule->setFilterExpression( editFilter->text() );
737  mRule->setLabel( editLabel->text() );
738  mRule->setDescription( editDescription->text() );
739  // caution: rule uses scale denom, scale widget uses true scales
740  mRule->setScaleMinDenom( groupScale->isChecked() ? mScaleRangeWidget->minimumScaleDenom() : 0 );
741  mRule->setScaleMaxDenom( groupScale->isChecked() ? mScaleRangeWidget->maximumScaleDenom() : 0 );
742  mRule->setSymbol( groupSymbol->isChecked() ? mSymbol->clone() : nullptr );
743 
744  QDialog::accept();
745 }
746 
748 
749 /*
750  setDragEnabled(true);
751  viewport()->setAcceptDrops(true);
752  setDropIndicatorShown(true);
753  setDragDropMode(QAbstractItemView::InternalMove);
754 */
755 
756 static QString _formatScale( int denom )
757 {
758  if ( denom != 0 )
759  {
760  QString txt = QString( "1:%L1" ).arg( denom );
761  return txt;
762  }
763  else
764  return QString();
765 }
766 
768 
770  : mR( r )
771 {
772 }
773 
775 {
776  if ( !index.isValid() )
777  return Qt::ItemIsDropEnabled;
778 
779  // allow drop only at first column
780  Qt::ItemFlag drop = ( index.column() == 0 ? Qt::ItemIsDropEnabled : Qt::NoItemFlags );
781 
782  Qt::ItemFlag checkable = ( index.column() == 0 ? Qt::ItemIsUserCheckable : Qt::NoItemFlags );
783 
784  return Qt::ItemIsEnabled | Qt::ItemIsSelectable |
785  Qt::ItemIsEditable | checkable |
786  Qt::ItemIsDragEnabled | drop;
787 }
788 
790 {
791  if ( !index.isValid() )
792  return QVariant();
793 
795 
796  if ( role == Qt::DisplayRole || role == Qt::ToolTipRole )
797  {
798  switch ( index.column() )
799  {
800  case 0:
801  return rule->label();
802  case 1:
803  if ( rule->isElse() )
804  {
805  return "ELSE";
806  }
807  else
808  {
809  return rule->filterExpression().isEmpty() ? tr( "(no filter)" ) : rule->filterExpression();
810  }
811  case 2:
812  return rule->dependsOnScale() ? _formatScale( rule->scaleMaxDenom() ) : QVariant();
813  case 3:
814  return rule->dependsOnScale() ? _formatScale( rule->scaleMinDenom() ) : QVariant();
815  case 4:
816  if ( mFeatureCountMap.count( rule ) == 1 )
817  {
818  return QVariant( mFeatureCountMap[rule].count );
819  }
820  return QVariant();
821  case 5:
822  if ( mFeatureCountMap.count( rule ) == 1 )
823  {
824  if ( role == Qt::DisplayRole )
825  {
826  return QVariant( mFeatureCountMap[rule].duplicateCount );
827  }
828  else // tooltip - detailed info about duplicates
829  {
830  if ( mFeatureCountMap[rule].duplicateCount > 0 )
831  {
832  QString tip = "<p style='margin:0px;'><ul>";
833  Q_FOREACH ( QgsRuleBasedRendererV2::Rule* duplicateRule, mFeatureCountMap[rule].duplicateCountMap.keys() )
834  {
835  QString label = duplicateRule->label().replace( '&', "&amp;" ).replace( '>', "&gt;" ).replace( '<', "&lt;" );
836  tip += tr( "<li><nobr>%1 features also in rule %2</nobr></li>" ).arg( mFeatureCountMap[rule].duplicateCountMap[duplicateRule] ).arg( label );
837  }
838  tip += "</ul>";
839  return tip;
840  }
841  else
842  {
843  return 0;
844  }
845  }
846  }
847  return QVariant();
848  default:
849  return QVariant();
850  }
851  }
852  else if ( role == Qt::DecorationRole && index.column() == 0 && rule->symbol() )
853  {
854  return QgsSymbolLayerV2Utils::symbolPreviewIcon( rule->symbol(), QSize( 16, 16 ) );
855  }
856  else if ( role == Qt::TextAlignmentRole )
857  {
858  return ( index.column() == 2 || index.column() == 3 ) ? Qt::AlignRight : Qt::AlignLeft;
859  }
860  else if ( role == Qt::FontRole && index.column() == 1 )
861  {
862  if ( rule->isElse() )
863  {
864  QFont italicFont;
865  italicFont.setItalic( true );
866  return italicFont;
867  }
868  return QVariant();
869  }
870  else if ( role == Qt::EditRole )
871  {
872  switch ( index.column() )
873  {
874  case 0:
875  return rule->label();
876  case 1:
877  return rule->filterExpression();
878  case 2:
879  return rule->scaleMaxDenom();
880  case 3:
881  return rule->scaleMinDenom();
882  default:
883  return QVariant();
884  }
885  }
886  else if ( role == Qt::CheckStateRole )
887  {
888  if ( index.column() != 0 )
889  return QVariant();
890  return rule->active() ? Qt::Checked : Qt::Unchecked;
891  }
892  else
893  return QVariant();
894 }
895 
896 QVariant QgsRuleBasedRendererV2Model::headerData( int section, Qt::Orientation orientation, int role ) const
897 {
898  if ( orientation == Qt::Horizontal && role == Qt::DisplayRole && section >= 0 && section < 7 )
899  {
900  QStringList lst;
901  lst << tr( "Label" ) << tr( "Rule" ) << tr( "Min. scale" ) << tr( "Max. scale" ) << tr( "Count" ) << tr( "Duplicate count" );
902  return lst[section];
903  }
904  else if ( orientation == Qt::Horizontal && role == Qt::ToolTipRole )
905  {
906  if ( section == 4 ) // Count
907  {
908  return tr( "Number of features in this rule." );
909  }
910  else if ( section == 5 ) // Duplicate count
911  {
912  return tr( "Number of features in this rule which are also present in other rule(s)." );
913  }
914  }
915 
916  return QVariant();
917 }
918 
920 {
921  if ( parent.column() > 0 )
922  return 0;
923 
924  QgsRuleBasedRendererV2::Rule* parentRule = ruleForIndex( parent );
925 
926  return parentRule->children().count();
927 }
928 
930 {
931  return 6;
932 }
933 
935 {
936  if ( hasIndex( row, column, parent ) )
937  {
938  QgsRuleBasedRendererV2::Rule* parentRule = ruleForIndex( parent );
939  QgsRuleBasedRendererV2::Rule* childRule = parentRule->children()[row];
940  return createIndex( row, column, childRule );
941  }
942  return QModelIndex();
943 }
944 
946 {
947  if ( !index.isValid() )
948  return QModelIndex();
949 
950  QgsRuleBasedRendererV2::Rule* childRule = ruleForIndex( index );
951  QgsRuleBasedRendererV2::Rule* parentRule = childRule->parent();
952 
953  if ( parentRule == mR->rootRule() )
954  return QModelIndex();
955 
956  // this is right: we need to know row number of our parent (in our grandparent)
957  int row = parentRule->parent()->children().indexOf( parentRule );
958 
959  return createIndex( row, 0, parentRule );
960 }
961 
962 bool QgsRuleBasedRendererV2Model::setData( const QModelIndex & index, const QVariant & value, int role )
963 {
964  if ( !index.isValid() )
965  return false;
966 
968 
969  if ( role == Qt::CheckStateRole )
970  {
971  rule->setActive( value.toInt() == Qt::Checked );
972  emit dataChanged( index, index );
973  return true;
974  }
975 
976  if ( role != Qt::EditRole )
977  return false;
978 
979  switch ( index.column() )
980  {
981  case 0: // label
982  rule->setLabel( value.toString() );
983  break;
984  case 1: // filter
985  rule->setFilterExpression( value.toString() );
986  break;
987  case 2: // scale min
988  rule->setScaleMaxDenom( value.toInt() );
989  break;
990  case 3: // scale max
991  rule->setScaleMinDenom( value.toInt() );
992  break;
993  default:
994  return false;
995  }
996 
997  emit dataChanged( index, index );
998  return true;
999 }
1000 
1002 {
1003  return Qt::MoveAction; // | Qt::CopyAction
1004 }
1005 
1007 {
1008  QStringList types;
1009  types << "application/vnd.text.list";
1010  return types;
1011 }
1012 
1013 QMimeData *QgsRuleBasedRendererV2Model::mimeData( const QModelIndexList &indexes ) const
1014 {
1015  QMimeData *mimeData = new QMimeData();
1016  QByteArray encodedData;
1017 
1018  QDataStream stream( &encodedData, QIODevice::WriteOnly );
1019 
1020  Q_FOREACH ( const QModelIndex &index, indexes )
1021  {
1022  // each item consists of several columns - let's add it with just first one
1023  if ( !index.isValid() || index.column() != 0 )
1024  continue;
1025 
1026  // we use a clone of the existing rule because it has a new unique rule key
1027  // non-unique rule keys would confuse other components using them (e.g. legend)
1028  QgsRuleBasedRendererV2::Rule* rule = ruleForIndex( index )->clone();
1029  QDomDocument doc;
1030  QgsSymbolV2Map symbols;
1031 
1032  QDomElement rootElem = doc.createElement( "rule_mime" );
1033  rootElem.setAttribute( "type", "renderer" ); // for determining whether rules are from renderer or labeling
1034  QDomElement rulesElem = rule->save( doc, symbols );
1035  rootElem.appendChild( rulesElem );
1036  QDomElement symbolsElem = QgsSymbolLayerV2Utils::saveSymbols( symbols, "symbols", doc );
1037  rootElem.appendChild( symbolsElem );
1038  doc.appendChild( rootElem );
1039 
1040  delete rule;
1041 
1042  stream << doc.toString( -1 );
1043  }
1044 
1045  mimeData->setData( "application/vnd.text.list", encodedData );
1046  return mimeData;
1047 }
1048 
1049 
1050 // manipulate DOM before dropping it so that rules are more useful
1052 {
1053  // labeling rules recognize only "description"
1054  if ( ruleElem.hasAttribute( "description" ) )
1055  ruleElem.setAttribute( "label", ruleElem.attribute( "description" ) );
1056 
1057  // run recursively
1058  QDomElement childRuleElem = ruleElem.firstChildElement( "rule" );
1059  while ( !childRuleElem.isNull() )
1060  {
1061  _labeling2rendererRules( childRuleElem );
1062  childRuleElem = childRuleElem.nextSiblingElement( "rule" );
1063  }
1064 }
1065 
1066 
1068  Qt::DropAction action, int row, int column, const QModelIndex &parent )
1069 {
1070  Q_UNUSED( column );
1071 
1072  if ( action == Qt::IgnoreAction )
1073  return true;
1074 
1075  if ( !data->hasFormat( "application/vnd.text.list" ) )
1076  return false;
1077 
1078  if ( parent.column() > 0 )
1079  return false;
1080 
1081  QByteArray encodedData = data->data( "application/vnd.text.list" );
1082  QDataStream stream( &encodedData, QIODevice::ReadOnly );
1083  int rows = 0;
1084 
1085  if ( row == -1 )
1086  {
1087  // the item was dropped at a parent - we may decide where to put the items - let's append them
1088  row = rowCount( parent );
1089  }
1090 
1091  while ( !stream.atEnd() )
1092  {
1093  QString text;
1094  stream >> text;
1095 
1096  QDomDocument doc;
1097  if ( !doc.setContent( text ) )
1098  continue;
1099  QDomElement rootElem = doc.documentElement();
1100  if ( rootElem.tagName() != "rule_mime" )
1101  continue;
1102  if ( rootElem.attribute( "type" ) == "labeling" )
1103  rootElem.appendChild( doc.createElement( "symbols" ) );
1104  QDomElement symbolsElem = rootElem.firstChildElement( "symbols" );
1105  if ( symbolsElem.isNull() )
1106  continue;
1107  QgsSymbolV2Map symbolMap = QgsSymbolLayerV2Utils::loadSymbols( symbolsElem );
1108  QDomElement ruleElem = rootElem.firstChildElement( "rule" );
1109  if ( rootElem.attribute( "type" ) == "labeling" )
1110  _labeling2rendererRules( ruleElem );
1112 
1113  insertRule( parent, row + rows, rule );
1114 
1115  ++rows;
1116  }
1117  return true;
1118 }
1119 
1121 {
1122  if ( index.isValid() )
1123  return static_cast<QgsRuleBasedRendererV2::Rule*>( index.internalPointer() );
1124  return mR->rootRule();
1125 }
1126 
1128 {
1129  QgsRuleBasedRendererV2::Rule* parentRule = ruleForIndex( parent );
1130 
1131  if ( row < 0 || row >= parentRule->children().count() )
1132  return false;
1133 
1134  QgsDebugMsg( QString( "Called: row %1 count %2 parent ~~%3~~" ).arg( row ).arg( count ).arg( parentRule->dump() ) );
1135 
1136  beginRemoveRows( parent, row, row + count - 1 );
1137 
1138  for ( int i = 0; i < count; i++ )
1139  {
1140  if ( row < parentRule->children().count() )
1141  {
1142  //QgsRuleBasedRendererV2::Rule* r = parentRule->children()[row];
1143  parentRule->removeChildAt( row );
1144  //parentRule->takeChildAt( row );
1145  }
1146  else
1147  {
1148  QgsDebugMsg( "trying to remove invalid index - this should not happen!" );
1149  }
1150  }
1151 
1152  endRemoveRows();
1153 
1154  return true;
1155 }
1156 
1157 
1159 {
1160  beginInsertRows( parent, before, before );
1161 
1162  QgsDebugMsg( QString( "insert before %1 rule: %2" ).arg( before ).arg( newrule->dump() ) );
1163 
1164  QgsRuleBasedRendererV2::Rule* parentRule = ruleForIndex( parent );
1165  parentRule->insertChild( before, newrule );
1166 
1167  endInsertRows();
1168 }
1169 
1171 {
1172  emit dataChanged( index( row, 0, parent ),
1173  index( row, columnCount( parent ), parent ) );
1174 }
1175 
1177 {
1178  emit dataChanged( index( 0, 0, idx ),
1179  index( rowCount( idx ) - 1, columnCount( idx ) - 1, idx ) );
1180 
1181  for ( int i = 0; i < rowCount( idx ); i++ )
1182  {
1183  updateRule( index( i, 0, idx ) );
1184  }
1185 }
1186 
1187 
1189 {
1190  if ( !index.isValid() )
1191  return;
1192 
1193  beginRemoveRows( index.parent(), index.row(), index.row() );
1194 
1195  QgsRuleBasedRendererV2::Rule* rule = ruleForIndex( index );
1196  rule->parent()->removeChild( rule );
1197 
1198  endRemoveRows();
1199 }
1200 
1202 {
1203  int row = rowCount( parent ); // only consider appending
1204  beginInsertRows( parent, row, row + count - 1 );
1205 }
1206 
1208 {
1209  emit endInsertRows();
1210 }
1211 
1213 {
1214  mFeatureCountMap = theCountMap;
1215  updateRule( QModelIndex() );
1216 }
1217 
1219 {
1221  updateRule( QModelIndex() );
1222 }
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 widgetChanged()
Emmited when something on the widget has changed.
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:108
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:456
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