QGIS API Documentation  2.11.0-Master
qgsdatadefinedbutton.cpp
Go to the documentation of this file.
1 /***************************************************************************
2  qgsdatadefinedbutton.cpp - Data defined selector button
3  --------------------------------------
4  Date : 27-April-2013
5  Copyright : (C) 2013 by Larry Shaffer
6  Email : larrys at dakcarto 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 
16 #include "qgsdatadefinedbutton.h"
17 
18 #include <qgsapplication.h>
19 #include <qgsdatadefined.h>
21 #include <qgsexpression.h>
22 #include <qgsmessageviewer.h>
23 #include <qgsvectorlayer.h>
24 
25 #include <QClipboard>
26 #include <QMenu>
27 #include <QMouseEvent>
28 #include <QPointer>
29 #include <QGroupBox>
30 
31 
32 QIcon QgsDataDefinedButton::mIconDataDefine;
33 QIcon QgsDataDefinedButton::mIconDataDefineOn;
34 QIcon QgsDataDefinedButton::mIconDataDefineError;
35 QIcon QgsDataDefinedButton::mIconDataDefineExpression;
36 QIcon QgsDataDefinedButton::mIconDataDefineExpressionOn;
37 QIcon QgsDataDefinedButton::mIconDataDefineExpressionError;
38 
40  const QgsVectorLayer* vl,
41  const QgsDataDefined* datadefined,
42  DataTypes datatypes,
43  QString description )
44  : QToolButton( parent )
45  , mExpressionContextCallback( 0 )
46  , mExpressionContextCallbackContext( 0 )
47 {
48  // set up static icons
49  if ( mIconDataDefine.isNull() )
50  {
51  mIconDataDefine = QgsApplication::getThemeIcon( "/mIconDataDefine.svg" );
52  mIconDataDefineOn = QgsApplication::getThemeIcon( "/mIconDataDefineOn.svg" );
53  mIconDataDefineError = QgsApplication::getThemeIcon( "/mIconDataDefineError.svg" );
54  mIconDataDefineExpression = QgsApplication::getThemeIcon( "/mIconDataDefineExpression.svg" );
55  mIconDataDefineExpressionOn = QgsApplication::getThemeIcon( "/mIconDataDefineExpressionOn.svg" );
56  mIconDataDefineExpressionError = QgsApplication::getThemeIcon( "/mIconDataDefineExpressionError.svg" );
57  }
58 
59  setFocusPolicy( Qt::StrongFocus );
60 
61  // set default tool button icon properties
62  setFixedSize( 30, 26 );
63  setStyleSheet( QString( "QToolButton{ background: none; border: 1px solid rgba(0, 0, 0, 0%);} QToolButton:focus { border: 1px solid palette(highlight); }" ) );
64  setIconSize( QSize( 24, 24 ) );
65  setPopupMode( QToolButton::InstantPopup );
66 
67  mDefineMenu = new QMenu( this );
68  connect( mDefineMenu, SIGNAL( aboutToShow() ), this, SLOT( aboutToShowMenu() ) );
69  connect( mDefineMenu, SIGNAL( triggered( QAction* ) ), this, SLOT( menuActionTriggered( QAction* ) ) );
70  setMenu( mDefineMenu );
71 
72  mFieldsMenu = new QMenu( this );
73  mActionDataTypes = new QAction( this );
74  // list fields and types in submenu, since there may be many
75  mActionDataTypes->setMenu( mFieldsMenu );
76 
77  mActionVariables = new QAction( tr( "Variable" ), this );
78  mVariablesMenu = new QMenu( this );
79  mActionVariables->setMenu( mVariablesMenu );
80 
81  mActionActive = new QAction( this );
82  QFont f = mActionActive->font();
83  f.setBold( true );
84  mActionActive->setFont( f );
85 
86  mActionDescription = new QAction( tr( "Description..." ), this );
87 
88  mActionExpDialog = new QAction( tr( "Edit..." ), this );
89  mActionExpression = 0;
90  mActionPasteExpr = new QAction( tr( "Paste" ), this );
91  mActionCopyExpr = new QAction( tr( "Copy" ), this );
92  mActionClearExpr = new QAction( tr( "Clear" ), this );
93  mActionAssistant = new QAction( tr( "Assistant..." ), this );
94  QFont assistantFont = mActionAssistant->font();
95  assistantFont.setBold( true );
96  mActionAssistant->setFont( assistantFont );
97  mDefineMenu->addAction( mActionAssistant );
98 
99  // set up sibling widget connections
100  connect( this, SIGNAL( dataDefinedActivated( bool ) ), this, SLOT( disableEnabledWidgets( bool ) ) );
101  connect( this, SIGNAL( dataDefinedActivated( bool ) ), this, SLOT( checkCheckedWidgets( bool ) ) );
102 
103  init( vl, datadefined, datatypes, description );
104 }
105 
107 {
108  mEnabledWidgets.clear();
109  mCheckedWidgets.clear();
110 }
111 
113  const QgsDataDefined* datadefined,
114  DataTypes datatypes,
115  QString description )
116 {
117  mVectorLayer = vl;
118  // construct default property if none or incorrect passed in
119  if ( !datadefined )
120  {
121  mProperty.insert( "active", "0" );
122  mProperty.insert( "useexpr", "0" );
123  mProperty.insert( "expression", "" );
124  mProperty.insert( "field", "" );
125  }
126  else
127  {
128  mProperty.insert( "active", datadefined->isActive() ? "1" : "0" );
129  mProperty.insert( "useexpr", datadefined->useExpression() ? "1" : "0" );
130  mProperty.insert( "expression", datadefined->expressionString() );
131  mProperty.insert( "field", datadefined->field() );
132  }
133 
134  mDataTypes = datatypes;
135  mFieldNameList.clear();
136  mFieldTypeList.clear();
137 
138  mInputDescription = description;
139  mFullDescription = QString( "" );
140  mUsageInfo = QString( "" );
141  mCurrentDefinition = QString( "" );
142 
143  // set up data types string
144  mDataTypesString = QString( "" );
145 
146  QStringList ts;
147  if ( mDataTypes.testFlag( String ) )
148  {
149  ts << tr( "string" );
150  }
151  if ( mDataTypes.testFlag( Int ) )
152  {
153  ts << tr( "int" );
154  }
155  if ( mDataTypes.testFlag( Double ) )
156  {
157  ts << tr( "double" );
158  }
159 
160  if ( !ts.isEmpty() )
161  {
162  mDataTypesString = ts.join( ", " );
163  mActionDataTypes->setText( tr( "Field type: " ) + mDataTypesString );
164  }
165 
166  if ( mVectorLayer )
167  {
168  // store just a list of fields of unknown type or those that match the expected type
169  const QgsFields& fields = mVectorLayer->fields();
170  for ( int i = 0; i < fields.count(); ++i )
171  {
172  const QgsField& f = fields.at( i );
173  bool fieldMatch = false;
174  // NOTE: these are the only QVariant enums supported at this time (see QgsField)
175  QString fieldType;
176  switch ( f.type() )
177  {
178  case QVariant::String:
179  fieldMatch = mDataTypes.testFlag( String );
180  fieldType = tr( "string" );
181  break;
182  case QVariant::Int:
183  fieldMatch = mDataTypes.testFlag( Int ) || mDataTypes.testFlag( Double );
184  fieldType = tr( "integer" );
185  break;
186  case QVariant::Double:
187  fieldMatch = mDataTypes.testFlag( Double );
188  fieldType = tr( "double" );
189  break;
190  case QVariant::Invalid:
191  default:
192  fieldMatch = true; // field type is unknown
193  fieldType = tr( "unknown type" );
194  }
195  if ( fieldMatch || mDataTypes.testFlag( AnyType ) )
196  {
197  mFieldNameList << f.name();
198  mFieldTypeList << fieldType;
199  }
200  }
201  }
202 
203  updateGui();
204 }
205 
207 {
208  if ( !dd )
209  return;
210 
211  dd->setActive( isActive() );
213  dd->setField( getField() );
215 }
216 
218 {
219  QgsDataDefined dd;
220  updateDataDefined( &dd );
221  return dd;
222 }
223 
225 {
226  // Ctrl-click to toggle activated state
227  if (( event->modifiers() & ( Qt::ControlModifier ) )
228  || event->button() == Qt::RightButton )
229  {
230  setActive( !isActive() );
231  updateGui();
232  event->ignore();
233  return;
234  }
235 
236  // pass to default behaviour
238 }
239 
240 void QgsDataDefinedButton::aboutToShowMenu()
241 {
242  mDefineMenu->clear();
243 
244  bool hasExp = !getExpression().isEmpty();
245  bool hasField = !getField().isEmpty();
246  QString ddTitle = tr( "Data defined override" );
247 
248  QAction* ddTitleAct = mDefineMenu->addAction( ddTitle );
249  QFont titlefont = ddTitleAct->font();
250  titlefont.setItalic( true );
251  ddTitleAct->setFont( titlefont );
252  ddTitleAct->setEnabled( false );
253 
254  bool addActiveAction = false;
255  if ( useExpression() && hasExp )
256  {
257  QgsExpression exp( getExpression() );
258  // whether expression is parse-able
259  addActiveAction = !exp.hasParserError();
260  }
261  else if ( !useExpression() && hasField )
262  {
263  // whether field exists
264  addActiveAction = mFieldNameList.contains( getField() );
265  }
266 
267  if ( addActiveAction )
268  {
269  ddTitleAct->setText( ddTitle + " (" + ( useExpression() ? tr( "expression" ) : tr( "field" ) ) + ")" );
270  mDefineMenu->addAction( mActionActive );
271  mActionActive->setText( isActive() ? tr( "Deactivate" ) : tr( "Activate" ) );
272  mActionActive->setData( QVariant( isActive() ? false : true ) );
273  }
274 
275  if ( !mFullDescription.isEmpty() )
276  {
277  mDefineMenu->addAction( mActionDescription );
278  }
279 
280  mDefineMenu->addSeparator();
281 
282  bool fieldActive = false;
283  if ( !mDataTypesString.isEmpty() )
284  {
285  QAction* fieldTitleAct = mDefineMenu->addAction( tr( "Attribute field" ) );
286  fieldTitleAct->setFont( titlefont );
287  fieldTitleAct->setEnabled( false );
288 
289  mDefineMenu->addAction( mActionDataTypes );
290 
291  mFieldsMenu->clear();
292 
293  if ( mFieldNameList.size() > 0 )
294  {
295 
296  for ( int j = 0; j < mFieldNameList.count(); ++j )
297  {
298  QString fldname = mFieldNameList.at( j );
299  QAction* act = mFieldsMenu->addAction( fldname + " (" + mFieldTypeList.at( j ) + ")" );
300  act->setData( QVariant( fldname ) );
301  if ( getField() == fldname )
302  {
303  act->setCheckable( true );
304  act->setChecked( !useExpression() );
305  fieldActive = !useExpression();
306  }
307  }
308  }
309  else
310  {
311  QAction* act = mFieldsMenu->addAction( tr( "No matching field types found" ) );
312  act->setEnabled( false );
313  }
314 
315  mDefineMenu->addSeparator();
316  }
317 
318  mFieldsMenu->menuAction()->setCheckable( true );
319  mFieldsMenu->menuAction()->setChecked( fieldActive );
320 
321  QAction* exprTitleAct = mDefineMenu->addAction( tr( "Expression" ) );
322  exprTitleAct->setFont( titlefont );
323  exprTitleAct->setEnabled( false );
324 
325  mVariablesMenu->clear();
326  bool variableActive = false;
327  if ( mExpressionContextCallback )
328  {
329  QgsExpressionContext context = mExpressionContextCallback( mExpressionContextCallbackContext );
330  QStringList variables = context.variableNames();
331  Q_FOREACH ( QString variable, variables )
332  {
333  if ( context.isReadOnly( variable ) ) //only want to show user-set variables
334  continue;
335  if ( variable.startsWith( "_" ) ) //no hidden variables
336  continue;
337 
338  QAction* act = mVariablesMenu->addAction( variable );
339  act->setData( QVariant( variable ) );
340 
341  if ( useExpression() && hasExp && getExpression() == "@" + variable )
342  {
343  act->setCheckable( true );
344  act->setChecked( true );
345  variableActive = true;
346  }
347  }
348  }
349 
350  if ( mVariablesMenu->actions().isEmpty() )
351  {
352  QAction* act = mVariablesMenu->addAction( tr( "No variables set" ) );
353  act->setEnabled( false );
354  }
355 
356  mDefineMenu->addAction( mActionVariables );
357  mVariablesMenu->menuAction()->setCheckable( true );
358  mVariablesMenu->menuAction()->setChecked( variableActive );
359 
360  if ( hasExp )
361  {
362  QString expString = getExpression();
363  if ( expString.length() > 35 )
364  {
365  expString.truncate( 35 );
366  expString.append( "..." );
367  }
368 
369  expString.prepend( tr( "Current: " ) );
370 
371  if ( !mActionExpression )
372  {
373  mActionExpression = new QAction( expString, this );
374  mActionExpression->setCheckable( true );
375  }
376  else
377  {
378  mActionExpression->setText( expString );
379  }
380  mDefineMenu->addAction( mActionExpression );
381  mActionExpression->setChecked( useExpression() && !variableActive );
382 
383  mDefineMenu->addAction( mActionExpDialog );
384  mDefineMenu->addAction( mActionCopyExpr );
385  mDefineMenu->addAction( mActionPasteExpr );
386  mDefineMenu->addAction( mActionClearExpr );
387  }
388  else
389  {
390  mDefineMenu->addAction( mActionExpDialog );
391  mDefineMenu->addAction( mActionPasteExpr );
392  }
393 
394  if ( mAssistant.data() )
395  {
396  mDefineMenu->addSeparator();
397  mDefineMenu->addAction( mActionAssistant );
398  }
399 }
400 
401 void QgsDataDefinedButton::menuActionTriggered( QAction* action )
402 {
403  if ( action == mActionActive )
404  {
405  setActive( mActionActive->data().toBool() );
406  updateGui();
407  }
408  else if ( action == mActionDescription )
409  {
410  showDescriptionDialog();
411  }
412  else if ( action == mActionExpDialog )
413  {
414  showExpressionDialog();
415  }
416  else if ( action == mActionExpression )
417  {
418  setUseExpression( true );
419  setActive( true );
420  updateGui();
421  }
422  else if ( action == mActionCopyExpr )
423  {
425  }
426  else if ( action == mActionPasteExpr )
427  {
428  QString exprString = QApplication::clipboard()->text();
429  if ( !exprString.isEmpty() )
430  {
431  setExpression( exprString );
432  setUseExpression( true );
433  setActive( true );
434  updateGui();
435  }
436  }
437  else if ( action == mActionClearExpr )
438  {
439  // only deactivate if defined expression is being used
440  if ( isActive() && useExpression() )
441  {
442  setUseExpression( false );
443  setActive( false );
444  }
445  setExpression( QString( "" ) );
446  updateGui();
447  }
448  else if ( action == mActionAssistant )
449  {
450  showAssistant();
451  }
452  else if ( mFieldsMenu->actions().contains( action ) ) // a field name clicked
453  {
454  if ( action->isEnabled() )
455  {
456  if ( getField() != action->text() )
457  {
458  setField( action->data().toString() );
459  }
460  setUseExpression( false );
461  setActive( true );
462  updateGui();
463  }
464  }
465  else if ( mVariablesMenu->actions().contains( action ) ) // a variable name clicked
466  {
467  if ( getExpression() != action->text().prepend( "@" ) )
468  {
469  setExpression( action->data().toString().prepend( "@" ) );
470  }
471  setUseExpression( true );
472  setActive( true );
473  updateGui();
474  }
475 }
476 
477 void QgsDataDefinedButton::showDescriptionDialog()
478 {
479  QgsMessageViewer* mv = new QgsMessageViewer( this );
480  mv->setWindowTitle( tr( "Data definition description" ) );
481  mv->setMessageAsHtml( mFullDescription );
482  mv->exec();
483 }
484 
485 void QgsDataDefinedButton::showAssistant()
486 {
487  if ( !mAssistant.data() )
488  return;
489 
490  if ( mAssistant->exec() == QDialog::Accepted )
491  {
492  QgsDataDefined dd = mAssistant->dataDefined();
494  setActive( dd.isActive() );
495  if ( dd.isActive() && dd.useExpression() )
497  else if ( dd.isActive() )
498  setField( dd.field() );
499  updateGui();
500  }
501  activateWindow(); // reset focus to parent window
502 }
503 
504 void QgsDataDefinedButton::showExpressionDialog()
505 {
506  QgsExpressionContext context = mExpressionContextCallback ? mExpressionContextCallback( mExpressionContextCallbackContext ) : QgsExpressionContext();
507 
508  QgsExpressionBuilderDialog d( const_cast<QgsVectorLayer*>( mVectorLayer ), getExpression(), this, "generic", context );
509  if ( d.exec() == QDialog::Accepted )
510  {
511  QString newExp = d.expressionText();
512  setExpression( d.expressionText().trimmed() );
513  bool hasExp = !newExp.isEmpty();
514 
515  setUseExpression( hasExp );
516  setActive( hasExp );
517  updateGui();
518  }
519  activateWindow(); // reset focus to parent window
520 }
521 
522 void QgsDataDefinedButton::updateGui()
523 {
524  QString oldDef = mCurrentDefinition;
525  QString newDef( "" );
526  bool hasExp = !getExpression().isEmpty();
527  bool hasField = !getField().isEmpty();
528 
529  if ( useExpression() && !hasExp )
530  {
531  setActive( false );
532  setUseExpression( false );
533  }
534  else if ( !useExpression() && !hasField )
535  {
536  setActive( false );
537  }
538 
539  QIcon icon = mIconDataDefine;
540  QString deftip = tr( "undefined" );
541  if ( useExpression() && hasExp )
542  {
543  icon = isActive() ? mIconDataDefineExpressionOn : mIconDataDefineExpression;
544  newDef = deftip = getExpression();
545 
546  QgsExpression exp( getExpression() );
547  if ( exp.hasParserError() )
548  {
549  setActive( false );
550  icon = mIconDataDefineExpressionError;
551  deftip = tr( "Parse error: %1" ).arg( exp.parserErrorString() );
552  newDef = "";
553  }
554  }
555  else if ( !useExpression() && hasField )
556  {
557  icon = isActive() ? mIconDataDefineOn : mIconDataDefine;
558  newDef = deftip = getField();
559 
560  if ( !mFieldNameList.contains( getField() ) )
561  {
562  setActive( false );
563  icon = mIconDataDefineError;
564  deftip = tr( "'%1' field missing" ).arg( getField() );
565  newDef = "";
566  }
567  }
568 
569  setIcon( icon );
570 
571  // update and emit current definition
572  if ( newDef != oldDef )
573  {
574  mCurrentDefinition = newDef;
575  emit dataDefinedChanged( mCurrentDefinition );
576  }
577 
578  // build full description for tool tip and popup dialog
579  mFullDescription = tr( "<b><u>Data defined override</u></b><br>" );
580 
581  mFullDescription += tr( "<b>Active: </b>%1&nbsp;&nbsp;&nbsp;<i>(ctrl|right-click toggles)</i><br>" ).arg( isActive() ? tr( "yes" ) : tr( "no" ) );
582 
583  if ( !mUsageInfo.isEmpty() )
584  {
585  mFullDescription += tr( "<b>Usage:</b><br>%1<br>" ).arg( mUsageInfo );
586  }
587 
588  if ( !mInputDescription.isEmpty() )
589  {
590  mFullDescription += tr( "<b>Expected input:</b><br>%1<br>" ).arg( mInputDescription );
591  }
592 
593  if ( !mDataTypesString.isEmpty() )
594  {
595  mFullDescription += tr( "<b>Valid input types:</b><br>%1<br>" ).arg( mDataTypesString );
596  }
597 
598  QString deftype( "" );
599  if ( deftip != tr( "undefined" ) )
600  {
601  deftype = QString( " (%1)" ).arg( useExpression() ? tr( "expression" ) : tr( "field" ) );
602  }
603 
604  // truncate long expressions, or tool tip may be too wide for screen
605  if ( deftip.length() > 75 )
606  {
607  deftip.truncate( 75 );
608  deftip.append( "..." );
609  }
610 
611  mFullDescription += tr( "<b>Current definition %1:</b><br>%2" ).arg( deftype ).arg( deftip );
612 
613  setToolTip( mFullDescription );
614 
615 }
616 
618 {
619  if ( isActive() != active )
620  {
621  mProperty.insert( "active", active ? "1" : "0" );
622  emit dataDefinedActivated( active );
623  }
624 }
625 
627 {
628  for ( int i = 0; i < wdgts.size(); ++i )
629  {
630  registerEnabledWidget( wdgts.at( i ) );
631  }
632 }
633 
635 {
636  QPointer<QWidget> wdgtP( wdgt );
637  if ( !mEnabledWidgets.contains( wdgtP ) )
638  {
639  mEnabledWidgets.append( wdgtP );
640  }
641 }
642 
644 {
645  QList<QWidget*> wdgtList;
646  for ( int i = 0; i < mEnabledWidgets.size(); ++i )
647  {
648  wdgtList << mEnabledWidgets.at( i );
649  }
650  return wdgtList;
651 }
652 
654 {
655  for ( int i = 0; i < mEnabledWidgets.size(); ++i )
656  {
657  mEnabledWidgets.at( i )->setDisabled( disable );
658  }
659 }
660 
662 {
663  for ( int i = 0; i < wdgts.size(); ++i )
664  {
665  registerCheckedWidget( wdgts.at( i ) );
666  }
667 }
668 
670 {
671  QPointer<QWidget> wdgtP( wdgt );
672  if ( !mCheckedWidgets.contains( wdgtP ) )
673  {
674  mCheckedWidgets.append( wdgtP );
675  }
676 }
677 
679 {
680  QList<QWidget*> wdgtList;
681  for ( int i = 0; i < mCheckedWidgets.size(); ++i )
682  {
683  wdgtList << mCheckedWidgets.at( i );
684  }
685  return wdgtList;
686 }
687 
689 {
690  mExpressionContextCallback = fnGetExpressionContext;
691  mExpressionContextCallbackContext = context;
692 }
693 
695 {
696  mActionAssistant->setText( title.isEmpty() ? tr( "Assistant..." ) : title );
697  mAssistant.reset( assistant );
698  mAssistant.data()->setParent( this, Qt::Dialog );
699 }
700 
702 {
703  // don't uncheck, only set to checked
704  if ( !check )
705  {
706  return;
707  }
708  for ( int i = 0; i < mCheckedWidgets.size(); ++i )
709  {
710  QAbstractButton *btn = qobject_cast< QAbstractButton * >( mCheckedWidgets.at( i ) );
711  if ( btn && btn->isCheckable() )
712  {
713  btn->setChecked( true );
714  continue;
715  }
716  QGroupBox *grpbx = qobject_cast< QGroupBox * >( mCheckedWidgets.at( i ) );
717  if ( grpbx && grpbx->isCheckable() )
718  {
719  grpbx->setChecked( true );
720  }
721  }
722 }
723 
725 {
726  // just something to reduce translation redundancy
727  return tr( "string " );
728 }
729 
731 {
732  return tr( "single character" );
733 }
734 
736 {
737  return tr( "bool [<b>1</b>=True|<b>0</b>=False]" );
738 }
739 
741 {
742  return tr( "string of variable length" );
743 }
744 
746 {
747  return tr( "int [&lt;= 0 =&gt;]" );
748 }
749 
751 {
752  return tr( "int [&gt;= 0]" );
753 }
754 
756 {
757  return tr( "int [&gt;= 1]" );
758 }
759 
761 {
762  return tr( "double [&lt;= 0.0 =&gt;]" );
763 }
764 
766 {
767  return tr( "double [&gt;= 0.0]" );
768 }
769 
771 {
772  return tr( "double [0.0-1.0]" );
773 }
774 
776 {
777  return tr( "double coord [<b>X,Y</b>] as &lt;= 0.0 =&gt;" );
778 }
779 
781 {
782  return tr( "double [-180.0 - 180.0]" );
783 }
784 
786 {
787  return tr( "int [0-100]" );
788 }
789 
791 {
792  return trString() + "[<b>MM</b>|<b>MapUnit</b>]";
793 }
794 
796 {
797  return trString() + "[<b>MM</b>|<b>MapUnit</b>|<b>Percent</b>]";
798 }
799 
801 {
802  return tr( "string [<b>r,g,b</b>] as int 0-255" );
803 }
804 
806 {
807  return tr( "string [<b>r,g,b,a</b>] as int 0-255" );
808 }
809 
811 {
812  return trString() + "[<b>Left</b>|<b>Center</b>|<b>Right</b>]";
813 }
814 
816 {
817  return trString() + "[<b>Bottom</b>|<b>Middle</b>|<b>Top</b>]";
818 }
819 
821 {
822  return trString() + "[<b>bevel</b>|<b>miter</b>|<b>round</b>]";
823 }
824 
826 {
827  return trString() + QString( "[<b>Normal</b>|<b>Lighten</b>|<b>Screen</b>|<b>Dodge</b>|<br>"
828  "<b>Addition</b>|<b>Darken</b>|<b>Multiply</b>|<b>Burn</b>|<b>Overlay</b>|<br>"
829  "<b>SoftLight</b>|<b>HardLight</b>|<b>Difference</b>|<b>Subtract</b>]" );
830 }
831 
833 {
834  return trString() + QString( "[<b>filepath</b>] as<br>"
835  "<b>''</b>=empty|absolute|search-paths-relative|<br>"
836  "project-relative|URL" );
837 }
838 
840 {
841  return tr( "string [<b>filepath</b>]" );
842 }
843 
845 {
846  return trString() + QString( "[<b>A5</b>|<b>A4</b>|<b>A3</b>|<b>A2</b>|<b>A1</b>|<b>A0</b>"
847  "<b>B5</b>|<b>B4</b>|<b>B3</b>|<b>B2</b>|<b>B1</b>|<b>B0</b>"
848  "<b>Legal</b>|<b>Ansi A</b>|<b>Ansi B</b>|<b>Ansi C</b>|<b>Ansi D</b>|<b>Ansi E</b>"
849  "<b>Arch A</b>|<b>Arch B</b>|<b>Arch C</b>|<b>Arch D</b>|<b>Arch E</b>|<b>Arch E1</b>]"
850  );
851 }
852 
854 {
855  return trString() + QString( "[<b>portrait</b>|<b>landscape</b>]" );
856 }
857 
859 {
860  return trString() + QString( "[<b>left</b>|<b>center</b>|<b>right</b>]" );
861 }
862 
864 {
865  return trString() + QString( "[<b>top</b>|<b>center</b>|<b>bottom</b>]" );
866 }
867 
869 {
870  return trString() + QString( "[<b>linear</b>|<b>radial</b>|<b>conical</b>]" );
871 }
872 
874 {
875  return trString() + QString( "[<b>feature</b>|<b>viewport</b>]" );
876 }
877 
879 {
880  return trString() + QString( "[<b>pad</b>|<b>repeat</b>|<b>reflect</b>]" );
881 }
882 
884 {
885  return trString() + QString( "[<b>no</b>|<b>solid</b>|<b>dash</b>|<b>dot</b>|<b>dash dot</b>|<b>dash dot dot</b>]" );
886 }
887 
889 {
890  return trString() + QString( "[<b>square</b>|<b>flat</b>|<b>round</b>]" );
891 }
892 
894 {
895  return trString() + QString( "[<b>solid</b>|<b>horizontal</b>|<b>vertical</b>|<b>cross</b>|<b>b_diagonal</b>|<b>f_diagonal"
896  "</b>|<b>diagonal_x</b>|<b>dense1</b>|<b>dense2</b>|<b>dense3</b>|<b>dense4</b>|<b>dense5"
897  "</b>|<b>dense6</b>|<b>dense7</b>|<b>no]" );
898 }
899 
901 {
902  return trString() + QString( "[<b>circle</b>|<b>rectangle</b>|<b>cross</b>|<b>triangle</b>]" );
903 }
904 
906 {
907  return tr( "[<b><dash>;<space></b>] e.g. '8;2;1;2'" );
908 }
void setText(const QString &text)
Class for parsing and evaluation of expressions (formerly called "search strings").
Definition: qgsexpression.h:88
const QString & name() const
Gets the name of the field.
Definition: qgsfield.cpp:70
void clear()
void setActive(bool active)
void setStyleSheet(const QString &styleSheet)
static QString gradientSpreadDesc()
An assistant (wizard) dialog, accessible from a QgsDataDefinedButton.
QString & append(QChar ch)
void setMenu(QMenu *menu)
void setExpression(QString exp)
Set the current defined expression.
void setField(QString field)
Set the current defined field.
void truncate(int position)
A container class for data source field mapping or expression.
static QString doublePosDesc()
static QString colorNoAlphaDesc()
static QString textVertAlignDesc()
QString field() const
Get the field which this QgsDataDefined represents.
QList< QWidget * > registeredEnabledWidgets()
Return widget siblings that get disabled/enabled when data definition or expression is set/unset...
static QString paperOrientationDesc()
QgsFields fields() const
Returns the list of fields of this layer.
void setFocusPolicy(Qt::FocusPolicy policy)
void dataDefinedChanged(const QString &definition)
Emitted when data definition or expression is changed.
void setChecked(bool)
QString & prepend(QChar ch)
QVariant data() const
static QIcon getThemeIcon(const QString &theName)
Helper to get a theme icon.
const T & at(int i) const
void addAction(QAction *action)
bool contains(const QString &str, Qt::CaseSensitivity cs) const
static QString unitsMmMuDesc()
void registerCheckedWidgets(QList< QWidget * > wdgts)
Register list of sibling widgets that get checked when data definition or expression is active...
static QString anyStringDesc()
int exec()
Container of fields for a vector layer.
Definition: qgsfield.h:177
void disableEnabledWidgets(bool disable)
Set siblings' enabled property when data definition or expression is set/unset.
void setMenu(QMenu *menu)
static QString lineStyleDesc()
QString expressionString() const
Returns the expression string of this QgsDataDefined.
void updateDataDefined(QgsDataDefined *dd) const
Updates a QgsDataDefined with the current settings from the button.
QString join(const QString &separator) const
void init(const QgsVectorLayer *vl, const QgsDataDefined *datadefined=0, DataTypes datatypes=AnyType, QString description=QString(""))
Initialize a newly constructed data defined button (useful if button already included from form layou...
static QString horizontalAnchorDesc()
void triggered(QAction *action)
QIcon icon() const
QString tr(const char *sourceText, const char *disambiguation, int n)
int size() const
void mouseReleaseEvent(QMouseEvent *event) override
void reset(T *other)
void setBold(bool enable)
void setMessageAsHtml(const QString &msg)
void clear()
void setUseExpression(bool use)
Controls if the field or the expression part is active.
QStringList variableNames() const
Returns a list of variables names set by all scopes in the context.
QgsExpressionContext(* ExpressionContextCallback)(const void *context)
Callback function for retrieving the expression context for the button.
void setActive(bool active)
Set whether the current data definition or expression is to be used.
static QString unitsMmMuPercentDesc()
int count(const T &value) const
void registerEnabledWidget(QWidget *wdgt)
Register a sibling widget that gets disabled/enabled when data definition or expression is set/unset...
void append(const T &value)
static QString textHorzAlignDesc()
void setChecked(bool checked)
static QString penJoinStyleDesc()
virtual void mousePressEvent(QMouseEvent *e)
static QString double180RotDesc()
QClipboard * clipboard()
static QString gradientTypeDesc()
void setField(const QString &field)
Set the field name which this QgsDataDefined represents.
void setIconSize(const QSize &size)
static QString intTranspDesc()
bool isEmpty() const
Expression contexts are used to encapsulate the parameters around which a QgsExpression should be eva...
bool isEmpty() const
bool startsWith(const QString &s, Qt::CaseSensitivity cs) const
bool isReadOnly(const QString &name) const
Returns whether a variable is read only, and should not be modifiable by users.
QString getExpression() const
The current defined expression.
int count() const
Return number of items.
Definition: qgsfield.cpp:285
bool isCheckable() const
QAction * addSeparator()
Encapsulate a field in an attribute table or data source.
Definition: qgsfield.h:40
const QgsField & at(int i) const
Get field at particular index (must be in range 0..N-1)
Definition: qgsfield.cpp:305
bool useExpression() const
Returns if the field or the expression part is active.
Qt::KeyboardModifiers modifiers() const
T * data() const
void setData(const QVariant &userData)
void registerEnabledWidgets(QList< QWidget * > wdgts)
Register list of sibling widgets that get disabled/enabled when data definition or expression is set/...
void setFixedSize(const QSize &s)
QList< QWidget * > registeredCheckedWidgets()
Return widget siblings that get checked when data definition or expression is active.
void registerGetExpressionContextCallback(ExpressionContextCallback fnGetExpressionContext, const void *context)
Register callback function for retrieving the expression context for the button.
static QString markerStyleDesc()
bool contains(const T &value) const
void dataDefinedActivated(bool active)
Emitted when active state changed.
void setCheckable(bool)
void setItalic(bool enable)
static QString blendModesDesc()
static QString gradientCoordModeDesc()
void setChecked(bool)
QString text(Mode mode) const
static QString trString()
Common descriptions for expected input values.
void registerCheckedWidget(QWidget *wdgt)
Register a sibling widget that get checked when data definition or expression is active.
QString getField() const
The current defined field.
void setAssistant(const QString &title, QgsDataDefinedAssistant *assistant)
Sets an assistant used to define the data defined object properties.
void activateWindow()
bool isCheckable() const
bool isNull() const
static QString verticalAnchorDesc()
void setWindowTitle(const QString &)
void setPopupMode(ToolButtonPopupMode mode)
static QString fillStyleDesc()
static QString paperSizeDesc()
void setUseExpression(bool use)
Set whether the current expression is to be used instead of field mapping.
void checkCheckedWidgets(bool check)
Set siblings' checked property when data definition or expression is active.
A generic message view for displaying QGIS messages.
int length() const
bool toBool() const
static QString intPosOneDesc()
iterator insert(const Key &key, const T &value)
void setText(const QString &text, Mode mode)
QAction * menuAction() const
bool isActive() const
Whether the current data definition or expression is to be used.
void setToolTip(const QString &)
bool useExpression() const
Whether the current expression is to be used instead of field mapping.
QgsDataDefined currentDataDefined() const
Returns a QgsDataDefined which reflects the current settings from the button.
QgsDataDefinedButton(QWidget *parent=0, const QgsVectorLayer *vl=0, const QgsDataDefined *datadefined=0, DataTypes datatypes=AnyType, QString description="")
Construct a new data defined button.
bool connect(const QObject *sender, const char *signal, const QObject *receiver, const char *method, Qt::ConnectionType type)
QList< QAction * > actions() const
static QString customDashDesc()
Represents a vector layer which manages a vector based data sets.
QString arg(qlonglong a, int fieldWidth, int base, const QChar &fillChar) const
QString toString() const
void setExpressionString(const QString &expr)
Sets the expression for this QgsDataDefined.
bool isActive() const
A generic dialog for building expression strings.
void setEnabled(bool)
static QString double0to1Desc()
static QString colorAlphaDesc()
QVariant::Type type() const
Gets variant type of the field as it will be retrieved from data source.
Definition: qgsfield.cpp:75