QGIS API Documentation 3.41.0-Master (3440c17df1d)
Loading...
Searching...
No Matches
qgsexpressiontreeview.cpp
Go to the documentation of this file.
1/***************************************************************************
2 qgsexpressiontreeview.cpp
3 --------------------------------------
4 Date : march 2020 - quarantine day 9
5 Copyright : (C) 2020 by Denis Rouzaud
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 <QMenu>
17#include <QMessageBox>
18#include <QVersionNumber>
19
21#include "moc_qgsexpressiontreeview.cpp"
22#include "qgis.h"
23#include "qgsvectorlayer.h"
25#include "qgssettings.h"
26#include "qgsrelationmanager.h"
27#include "qgsapplication.h"
28#include "qgsiconutils.h"
29
30
32QString formatRelationHelp( const QgsRelation &relation )
33{
34 QString text = QStringLiteral( "<h3>%1</h3>\n<div class=\"description\"><p>%2</p></div>" )
35 .arg( QCoreApplication::translate( "relation_help", "relation %1" ).arg( relation.name() ),
36 QObject::tr( "Inserts the relation ID for the relation named '%1'." ).arg( relation.name() ) );
37
38 text += QStringLiteral( "<h4>%1</h4><div class=\"description\"><pre>%2</pre></div>" )
39 .arg( QObject::tr( "Current value" ), relation.id() );
40
41 return text;
42}
43
44
46QString formatLayerHelp( const QgsMapLayer *layer )
47{
48 QString text = QStringLiteral( "<h3>%1</h3>\n<div class=\"description\"><p>%2</p></div>" )
49 .arg( QCoreApplication::translate( "layer_help", "map layer %1" ).arg( layer->name() ),
50 QObject::tr( "Inserts the layer ID for the layer named '%1'." ).arg( layer->name() ) );
51
52 text += QStringLiteral( "<h4>%1</h4><div class=\"description\"><pre>%2</pre></div>" )
53 .arg( QObject::tr( "Current value" ), layer->id() );
54
55 return text;
56}
57
59QString formatRecentExpressionHelp( const QString &label, const QString &expression )
60{
61 QString text = QStringLiteral( "<h3>%1</h3>\n<div class=\"description\"><p>%2</p></div>" )
62 .arg( QCoreApplication::translate( "recent_expression_help", "expression %1" ).arg( label ),
63 QCoreApplication::translate( "recent_expression_help", "Recently used expression." ) );
64
65 text += QStringLiteral( "<h4>%1</h4><div class=\"description\"><pre>%2</pre></div>" )
66 .arg( QObject::tr( "Expression" ), expression );
67
68 return text;
69}
70
72QString formatUserExpressionHelp( const QString &label, const QString &expression, const QString &description )
73{
74 QString text = QStringLiteral( "<h3>%1</h3>\n<div class=\"description\"><p>%2</p></div>" )
75 .arg( QCoreApplication::translate( "user_expression_help", "expression %1" ).arg( label ), description );
76
77 text += QStringLiteral( "<h4>%1</h4><div class=\"description\"><pre>%2</pre></div>" )
78 .arg( QObject::tr( "Expression" ), expression );
79
80 return text;
81}
82
84QString formatVariableHelp( const QString &variable, const QString &description, bool showValue, const QVariant &value )
85{
86 QString text = QStringLiteral( "<h3>%1</h3>\n<div class=\"description\"><p>%2</p></div>" )
87 .arg( QCoreApplication::translate( "variable_help", "variable %1" ).arg( variable ), description );
88
89 if ( showValue )
90 {
91 QString valueString = !value.isValid()
92 ? QCoreApplication::translate( "variable_help", "not set" )
93 : QStringLiteral( "<pre>%1</pre>" ).arg( QgsExpression::formatPreviewString( value ) );
94
95 text += QStringLiteral( "<h4>%1</h4><div class=\"description\"><p>%2</p></div>" )
96 .arg( QObject::tr( "Current value" ), valueString );
97 }
98
99 return text;
100}
101
102
103// ****************************
104// ****************************
105// QgsExpressionTreeView
106// ****************************
107
108
110 : QTreeView( parent )
111 , mProject( QgsProject::instance() )
112{
113 connect( this, &QTreeView::doubleClicked, this, &QgsExpressionTreeView::onDoubleClicked );
114
115 mModel = std::make_unique<QStandardItemModel>();
116 mProxyModel = std::make_unique<QgsExpressionItemSearchProxy>();
117 mProxyModel->setDynamicSortFilter( true );
118 mProxyModel->setSourceModel( mModel.get() );
119 setModel( mProxyModel.get() );
120 setSortingEnabled( true );
121 sortByColumn( 0, Qt::AscendingOrder );
122
123 setSelectionMode( QAbstractItemView::SelectionMode::SingleSelection );
124
125 setContextMenuPolicy( Qt::CustomContextMenu );
126 connect( this, &QWidget::customContextMenuRequested, this, &QgsExpressionTreeView::showContextMenu );
127 connect( selectionModel(), &QItemSelectionModel::currentChanged, this, &QgsExpressionTreeView::currentItemChanged );
128
129 updateFunctionTree();
131
132 // select the first item in the function list
133 // in order to avoid a blank help widget
134 QModelIndex firstItem = mProxyModel->index( 0, 0, QModelIndex() );
135 setCurrentIndex( firstItem );
136}
137
139{
140 mLayer = layer;
141
142 //TODO - remove existing layer scope from context
143
144 if ( mLayer )
145 mExpressionContext << QgsExpressionContextUtils::layerScope( mLayer );
146
148}
149
151{
152 mExpressionContext = context;
153 updateFunctionTree();
155 loadRecent( mRecentKey );
157}
158
160{
161 mMenuProvider = provider;
162}
163
165{
166 updateFunctionTree();
168 loadRecent( mRecentKey );
170}
171
173{
174 QModelIndex idx = mProxyModel->mapToSource( currentIndex() );
175 QgsExpressionItem *item = static_cast<QgsExpressionItem *>( mModel->itemFromIndex( idx ) );
176 return item;
177}
178
179QStandardItemModel *QgsExpressionTreeView::model()
180{
181 return mModel.get();
182}
183
185{
186 return mProject;
187}
188
190{
191 mProject = project;
192 updateFunctionTree();
193}
194
195
196void QgsExpressionTreeView::setSearchText( const QString &text )
197{
198 mProxyModel->setFilterString( text );
199 if ( text.isEmpty() )
200 {
201 collapseAll();
202 }
203 else
204 {
205 expandAll();
206 QModelIndex index = mProxyModel->index( 0, 0 );
207 if ( mProxyModel->hasChildren( index ) )
208 {
209 QModelIndex child = mProxyModel->index( 0, 0, index );
210 selectionModel()->setCurrentIndex( child, QItemSelectionModel::ClearAndSelect );
211 }
212 }
213}
214
215void QgsExpressionTreeView::onDoubleClicked( const QModelIndex &index )
216{
217 QModelIndex idx = mProxyModel->mapToSource( index );
218 QgsExpressionItem *item = static_cast<QgsExpressionItem *>( mModel->itemFromIndex( idx ) );
219 if ( !item )
220 return;
221
222 // Don't handle the double-click if we are on a header node.
223 if ( item->getItemType() == QgsExpressionItem::Header )
224 return;
225
227}
228
229void QgsExpressionTreeView::showContextMenu( QPoint pt )
230{
231 QModelIndex idx = indexAt( pt );
232 idx = mProxyModel->mapToSource( idx );
233 QgsExpressionItem *item = static_cast<QgsExpressionItem *>( mModel->itemFromIndex( idx ) );
234 if ( !item )
235 return;
236
237 if ( !mMenuProvider )
238 return;
239
240 QMenu *menu = mMenuProvider->createContextMenu( item );
241
242 if ( menu )
243 menu->popup( mapToGlobal( pt ) );
244}
245
246void QgsExpressionTreeView::currentItemChanged( const QModelIndex &index, const QModelIndex & )
247{
248 // Get the item
249 QModelIndex idx = mProxyModel->mapToSource( index );
250 QgsExpressionItem *item = static_cast<QgsExpressionItem *>( mModel->itemFromIndex( idx ) );
251 if ( !item )
252 return;
253
254 emit currentExpressionItemChanged( item );
255}
256
257void QgsExpressionTreeView::updateFunctionTree()
258{
259 mModel->clear();
260 mExpressionGroups.clear();
261
262 //list of pairs where the first is the name and the second is the expression value when adding it
263 static const QList< QPair<QString, QString> > operators = QList< QPair<QString, QString> >()
264 << QPair<QString, QString>( QStringLiteral( "+" ), QStringLiteral( " + " ) )
265 << QPair<QString, QString>( QStringLiteral( "-" ), QStringLiteral( " - " ) )
266 << QPair<QString, QString>( QStringLiteral( "*" ), QStringLiteral( " * " ) )
267 << QPair<QString, QString>( QStringLiteral( "/" ), QStringLiteral( " / " ) )
268 << QPair<QString, QString>( QStringLiteral( "//" ), QStringLiteral( " // " ) )
269 << QPair<QString, QString>( QStringLiteral( "%" ), QStringLiteral( " % " ) )
270 << QPair<QString, QString>( QStringLiteral( "^" ), QStringLiteral( " ^ " ) )
271 << QPair<QString, QString>( QStringLiteral( "=" ), QStringLiteral( " = " ) )
272 << QPair<QString, QString>( QStringLiteral( "~" ), QStringLiteral( " ~ " ) )
273 << QPair<QString, QString>( QStringLiteral( ">" ), QStringLiteral( " > " ) )
274 << QPair<QString, QString>( QStringLiteral( "<" ), QStringLiteral( " < " ) )
275 << QPair<QString, QString>( QStringLiteral( "<>" ), QStringLiteral( " <> " ) )
276 << QPair<QString, QString>( QStringLiteral( "<=" ), QStringLiteral( " <= " ) )
277 << QPair<QString, QString>( QStringLiteral( ">=" ), QStringLiteral( " >= " ) )
278 << QPair<QString, QString>( QStringLiteral( "[]" ), QStringLiteral( "[]" ) )
279 << QPair<QString, QString>( QStringLiteral( "||" ), QStringLiteral( " || " ) )
280 << QPair<QString, QString>( QStringLiteral( "BETWEEN" ), QStringLiteral( " BETWEEN " ) )
281 << QPair<QString, QString>( QStringLiteral( "NOT BETWEEN" ), QStringLiteral( " NOT BETWEEN " ) )
282 << QPair<QString, QString>( QStringLiteral( "IN" ), QStringLiteral( " IN " ) )
283 << QPair<QString, QString>( QStringLiteral( "LIKE" ), QStringLiteral( " LIKE " ) )
284 << QPair<QString, QString>( QStringLiteral( "ILIKE" ), QStringLiteral( " ILIKE " ) )
285 << QPair<QString, QString>( QStringLiteral( "IS" ), QStringLiteral( " IS " ) )
286 << QPair<QString, QString>( QStringLiteral( "IS NOT" ), QStringLiteral( " IS NOT " ) )
287 << QPair<QString, QString>( QStringLiteral( "OR" ), QStringLiteral( " OR " ) )
288 << QPair<QString, QString>( QStringLiteral( "AND" ), QStringLiteral( " AND " ) )
289 << QPair<QString, QString>( QStringLiteral( "NOT" ), QStringLiteral( " NOT " ) );
290 for ( const auto &name : operators )
291 {
292 registerItem( QStringLiteral( "Operators" ), name.first, name.second, QString(), QgsExpressionItem::ExpressionNode, false, -1, QIcon(), QgsExpression::tags( name.first ) );
293 }
294
295 QString casestring = QStringLiteral( "CASE WHEN condition THEN result END" );
296 registerItem( QStringLiteral( "Conditionals" ), QStringLiteral( "CASE" ), casestring, QString(), QgsExpressionItem::ExpressionNode, false, -1, QIcon(), QgsExpression::tags( "CASE" ) );
297
298 // use -1 as sort order here -- NULL should always show before the field list
299 registerItem( QStringLiteral( "Fields and Values" ), QStringLiteral( "NULL" ), QStringLiteral( "NULL" ), QString(), QgsExpressionItem::ExpressionNode, false, -1 );
300
301 // Load the functions from the QgsExpression class
302 int count = QgsExpression::functionCount();
303 for ( int i = 0; i < count; i++ )
304 {
306 QString name = func->name();
307 if ( name.startsWith( '_' ) ) // do not display private functions
308 continue;
309 if ( func->isDeprecated() ) // don't show deprecated functions
310 continue;
311 if ( func->isContextual() )
312 {
313 //don't show contextual functions by default - it's up the the QgsExpressionContext
314 //object to provide them if supported
315 continue;
316 }
317 if ( func->params() != 0 )
318 name += '(';
319 else if ( !name.startsWith( '$' ) )
320 name += QLatin1String( "()" );
321 // this is where the functions are being registered, including functions under "Custom"
322 registerItemForAllGroups( func->groups(), func->name(), ' ' + name + ' ', func->helpText(), QgsExpressionItem::ExpressionNode, mExpressionContext.isHighlightedFunction( func->name() ), 1, QgsExpression::tags( func->name() ) );
323 }
324
325 // load relation names
326 loadRelations();
327
328 // load layer IDs
329 loadLayers();
330
331 loadExpressionContext();
332}
333
334QgsExpressionItem *QgsExpressionTreeView::registerItem( const QString &group,
335 const QString &label,
336 const QString &expressionText,
337 const QString &helpText,
338 QgsExpressionItem::ItemType type, bool highlightedItem, int sortOrder, const QIcon &icon, const QStringList &tags, const QString &name )
339{
340 QgsExpressionItem *item = new QgsExpressionItem( label, expressionText, helpText, type );
341 item->setData( label, Qt::UserRole );
342 item->setData( sortOrder, QgsExpressionItem::CUSTOM_SORT_ROLE );
343 item->setData( tags, QgsExpressionItem::SEARCH_TAGS_ROLE );
344 item->setData( name, QgsExpressionItem::ITEM_NAME_ROLE );
345 item->setIcon( icon );
346
347 // Look up the group and insert the new function.
348 if ( mExpressionGroups.contains( group ) )
349 {
350 QgsExpressionItem *groupNode = mExpressionGroups.value( group );
351 groupNode->appendRow( item );
352 }
353 else
354 {
355 // If the group doesn't exist yet we make it first.
356 QgsExpressionItem *newgroupNode = new QgsExpressionItem( QgsExpression::group( group ), QString(), QgsExpressionItem::Header );
357 newgroupNode->setData( group, Qt::UserRole );
358 //Recent group should always be last group
359 newgroupNode->setData( group.startsWith( QLatin1String( "Recent (" ) ) ? 2 : 1, QgsExpressionItem::CUSTOM_SORT_ROLE );
360 newgroupNode->appendRow( item );
361 newgroupNode->setBackground( QBrush( QColor( 150, 150, 150, 150 ) ) );
362 mModel->appendRow( newgroupNode );
363 mExpressionGroups.insert( group, newgroupNode );
364 }
365
366 if ( highlightedItem )
367 {
368 //insert a copy as a top level item
369 QgsExpressionItem *topLevelItem = new QgsExpressionItem( label, expressionText, helpText, type );
370 topLevelItem->setData( label, Qt::UserRole );
371 item->setData( 0, QgsExpressionItem::CUSTOM_SORT_ROLE );
372 QFont font = topLevelItem->font();
373 font.setBold( true );
374 topLevelItem->setFont( font );
375 mModel->appendRow( topLevelItem );
376 }
377 return item;
378}
379
380void QgsExpressionTreeView::registerItemForAllGroups( const QStringList &groups, const QString &label, const QString &expressionText, const QString &helpText, QgsExpressionItem::ItemType type, bool highlightedItem, int sortOrder, const QStringList &tags )
381{
382 const auto constGroups = groups;
383 for ( const QString &group : constGroups )
384 {
385 registerItem( group, label, expressionText, helpText, type, highlightedItem, sortOrder, QIcon(), tags );
386 }
387}
388
389void QgsExpressionTreeView::loadExpressionContext()
390{
391 QStringList variableNames = mExpressionContext.filteredVariableNames();
392 const auto constVariableNames = variableNames;
393 for ( const QString &variable : constVariableNames )
394 {
395 registerItem( QStringLiteral( "Variables" ), variable, " @" + variable + ' ',
396 formatVariableHelp( variable, mExpressionContext.description( variable ), true, mExpressionContext.variable( variable ) ),
398 mExpressionContext.isHighlightedVariable( variable ) );
399 }
400
401 // Load the functions from the expression context
402 QStringList contextFunctions = mExpressionContext.functionNames();
403 const auto constContextFunctions = contextFunctions;
404 for ( const QString &functionName : constContextFunctions )
405 {
406 QgsExpressionFunction *func = mExpressionContext.function( functionName );
407 QString name = func->name();
408 if ( name.startsWith( '_' ) ) // do not display private functions
409 continue;
410 if ( func->params() != 0 )
411 name += '(';
412 registerItemForAllGroups( func->groups(), func->name(), ' ' + name + ' ', func->helpText(), QgsExpressionItem::ExpressionNode, mExpressionContext.isHighlightedFunction( func->name() ), 1, QgsExpression::tags( func->name() ) );
413 }
414}
415
416void QgsExpressionTreeView::loadLayers()
417{
418 if ( !mProject )
419 return;
420
421 QMap<QString, QgsMapLayer *> layers = mProject->mapLayers();
422 QMap<QString, QgsMapLayer *>::const_iterator layerIt = layers.constBegin();
423 for ( ; layerIt != layers.constEnd(); ++layerIt )
424 {
425 QIcon icon = QgsIconUtils::iconForLayer( layerIt.value() );
426 QgsExpressionItem *parentItem = registerItem( QStringLiteral( "Map Layers" ), layerIt.value()->name(), QStringLiteral( "'%1'" ).arg( layerIt.key() ), formatLayerHelp( layerIt.value() ), QgsExpressionItem::ExpressionNode, false, 99, icon );
427 loadLayerFields( qobject_cast<QgsVectorLayer *>( layerIt.value() ), parentItem );
428 }
429
430}
431
432void QgsExpressionTreeView::loadLayerFields( QgsVectorLayer *layer, QgsExpressionItem *parentItem )
433{
434 if ( !layer )
435 return;
436
437 const QgsFields fields = layer->fields();
438 for ( int fieldIdx = 0; fieldIdx < fields.count(); ++fieldIdx )
439 {
440 const QgsField field = fields.at( fieldIdx );
441 QIcon icon = fields.iconForField( fieldIdx );
442 const QString label { field.displayNameWithAlias() };
443 QgsExpressionItem *item = new QgsExpressionItem( label, " '" + field.name() + "' ", QString(), QgsExpressionItem::Field );
444 item->setData( label, Qt::UserRole );
445 item->setData( 99, QgsExpressionItem::CUSTOM_SORT_ROLE );
446 item->setData( QStringList(), QgsExpressionItem::SEARCH_TAGS_ROLE );
447 item->setData( field.name(), QgsExpressionItem::ITEM_NAME_ROLE );
448 item->setData( layer->id(), QgsExpressionItem::LAYER_ID_ROLE );
449 item->setIcon( icon );
450 parentItem->appendRow( item );
451 }
452}
453
455{
456 for ( int i = 0; i < fields.count(); ++i )
457 {
458 const QgsField field = fields.at( i );
459 QIcon icon = fields.iconForField( i );
460 registerItem( QStringLiteral( "Fields and Values" ), field.displayNameWithAlias(),
461 " \"" + field.name() + "\" ", QString(), QgsExpressionItem::Field, false, i, icon, QStringList(), field.name() );
462 }
463}
464
465void QgsExpressionTreeView::loadFieldNames()
466{
467 // Cleanup
468 if ( mExpressionGroups.contains( QStringLiteral( "Fields and Values" ) ) )
469 {
470 QgsExpressionItem *node = mExpressionGroups.value( QStringLiteral( "Fields and Values" ) );
471 node->removeRows( 0, node->rowCount() );
472 // Re-add NULL and feature variables
473 // use -1 as sort order here -- NULL and feature variables should always show before the field list
474 registerItem( QStringLiteral( "Fields and Values" ), QStringLiteral( "NULL" ), QStringLiteral( "NULL" ), QString(), QgsExpressionItem::ExpressionNode, false, -1 );
475 }
476
477 if ( mLayer )
478 {
479 // Add feature variables to record and attributes group (and highlighted items)
480
481 const QString currentFeatureHelp = formatVariableHelp( QStringLiteral( "feature" ), QgsExpression::variableHelpText( QStringLiteral( "feature" ) ), false, QVariant() );
482 const QString currentFeatureIdHelp = formatVariableHelp( QStringLiteral( "id" ), QgsExpression::variableHelpText( QStringLiteral( "id" ) ), false, QVariant() );
483 const QString currentGeometryHelp = formatVariableHelp( QStringLiteral( "geometry" ), QgsExpression::variableHelpText( QStringLiteral( "geometry" ) ), false, QVariant() );
484
485 registerItem( QStringLiteral( "Fields and Values" ), QStringLiteral( "feature" ), QStringLiteral( "@feature" ), currentFeatureHelp, QgsExpressionItem::ExpressionNode, false, -1 );
486 registerItem( QStringLiteral( "Fields and Values" ), QStringLiteral( "id" ), QStringLiteral( "@id" ), currentFeatureIdHelp, QgsExpressionItem::ExpressionNode, false, -1 );
487 registerItem( QStringLiteral( "Fields and Values" ), QStringLiteral( "geometry" ), QStringLiteral( "@geometry" ), currentGeometryHelp, QgsExpressionItem::ExpressionNode, false, -1 );
488
489 registerItem( QStringLiteral( "Variables" ), QStringLiteral( "feature" ), QStringLiteral( "@feature" ), currentFeatureHelp, QgsExpressionItem::ExpressionNode );
490 registerItem( QStringLiteral( "Variables" ), QStringLiteral( "id" ), QStringLiteral( "@id" ), currentFeatureIdHelp, QgsExpressionItem::ExpressionNode );
491 registerItem( QStringLiteral( "Variables" ), QStringLiteral( "geometry" ), QStringLiteral( "@geometry" ), currentGeometryHelp, QgsExpressionItem::ExpressionNode, false );
492
493 registerItem( QStringLiteral( "Record and Attributes" ), QStringLiteral( "feature" ), QStringLiteral( "@feature" ), currentFeatureHelp, QgsExpressionItem::ExpressionNode, true, -1 );
494 registerItem( QStringLiteral( "Record and Attributes" ), QStringLiteral( "id" ), QStringLiteral( "@id" ), currentFeatureIdHelp, QgsExpressionItem::ExpressionNode, true, -1 );
495 registerItem( QStringLiteral( "Record and Attributes" ), QStringLiteral( "geometry" ), QStringLiteral( "@geometry" ), currentGeometryHelp, QgsExpressionItem::ExpressionNode, true, -1 );
496 }
497
498 // this can happen if fields are manually set
499 if ( !mLayer )
500 return;
501
502 const QgsFields &fields = mLayer->fields();
503
504 loadFieldNames( fields );
505}
506
507void QgsExpressionTreeView::loadRelations()
508{
509 if ( !mProject )
510 return;
511
512 QMap<QString, QgsRelation> relations = mProject->relationManager()->relations();
513 QMap<QString, QgsRelation>::const_iterator relIt = relations.constBegin();
514 for ( ; relIt != relations.constEnd(); ++relIt )
515 {
516 registerItemForAllGroups( QStringList() << tr( "Relations" ), relIt->name(), QStringLiteral( "'%1'" ).arg( relIt->id() ), formatRelationHelp( relIt.value() ) );
517 }
518}
519
520void QgsExpressionTreeView::loadRecent( const QString &collection )
521{
522 mRecentKey = collection;
523 QString name = tr( "Recent (%1)" ).arg( collection );
524 if ( mExpressionGroups.contains( name ) )
525 {
526 QgsExpressionItem *node = mExpressionGroups.value( name );
527 node->removeRows( 0, node->rowCount() );
528 }
529
530 QgsSettings settings;
531 const QString location = QStringLiteral( "/expressions/recent/%1" ).arg( collection );
532 const QStringList expressions = settings.value( location ).toStringList();
533 int i = 0;
534 for ( const QString &expression : expressions )
535 {
536 QString help = formatRecentExpressionHelp( expression, expression );
537 QString label = expression;
538 label.replace( '\n', ' ' );
539 registerItem( name, label, expression, help, QgsExpressionItem::ExpressionNode, false, i );
540 i++;
541 }
542}
543
544void QgsExpressionTreeView::saveToRecent( const QString &expressionText, const QString &collection )
545{
546 QgsSettings settings;
547 QString location = QStringLiteral( "/expressions/recent/%1" ).arg( collection );
548 QStringList expressions = settings.value( location ).toStringList();
549 expressions.removeAll( expressionText );
550
551 expressions.prepend( expressionText );
552
553 while ( expressions.count() > 20 )
554 {
555 expressions.pop_back();
556 }
557
558 settings.setValue( location, expressions );
559 loadRecent( collection );
560}
561
562void QgsExpressionTreeView::saveToUserExpressions( const QString &label, const QString &expression, const QString &helpText )
563{
564 QgsSettings settings;
565 const QString location = QStringLiteral( "user" );
566 settings.beginGroup( location, QgsSettings::Section::Expressions );
567 settings.beginGroup( label );
568 settings.setValue( QStringLiteral( "expression" ), expression );
569 settings.setValue( QStringLiteral( "helpText" ), helpText );
571 // Scroll
572 const QModelIndexList idxs { mModel->match( mModel->index( 0, 0 ), Qt::DisplayRole, label, 1, Qt::MatchFlag::MatchRecursive ) };
573 if ( ! idxs.isEmpty() )
574 {
575 scrollTo( idxs.first() );
576 }
577}
578
580{
581 QgsSettings settings;
582 settings.remove( QStringLiteral( "user/%1" ).arg( label ), QgsSettings::Section::Expressions );
584}
585
586// this is potentially very slow if there are thousands of user expressions, every time entire cleanup and load
588{
589 // Cleanup
590 if ( mExpressionGroups.contains( QStringLiteral( "UserGroup" ) ) )
591 {
592 QgsExpressionItem *node = mExpressionGroups.value( QStringLiteral( "UserGroup" ) );
593 node->removeRows( 0, node->rowCount() );
594 }
595
596 QgsSettings settings;
597 const QString location = QStringLiteral( "user" );
598 settings.beginGroup( location, QgsSettings::Section::Expressions );
599 QString helpText;
600 QString expression;
601 int i = 0;
602 mUserExpressionLabels = settings.childGroups();
603 for ( const auto &label : std::as_const( mUserExpressionLabels ) )
604 {
605 settings.beginGroup( label );
606 expression = settings.value( QStringLiteral( "expression" ) ).toString();
607 helpText = formatUserExpressionHelp( label, expression, settings.value( QStringLiteral( "helpText" ) ).toString() );
608 registerItem( QStringLiteral( "UserGroup" ), label, expression, helpText, QgsExpressionItem::ExpressionNode, false, i++ );
609 settings.endGroup();
610 }
611}
612
614{
615 return mUserExpressionLabels;
616}
617
619{
620 const QString group = QStringLiteral( "user" );
621 QgsSettings settings;
622 QJsonArray exportList;
623 QJsonObject exportObject
624 {
625 {"qgis_version", Qgis::version()},
626 {"exported_at", QDateTime::currentDateTime().toString( Qt::ISODate )},
627 {"author", QgsApplication::userFullName()},
628 {"expressions", exportList}
629 };
630
632
633 mUserExpressionLabels = settings.childGroups();
634
635 for ( const QString &label : std::as_const( mUserExpressionLabels ) )
636 {
637 settings.beginGroup( label );
638
639 const QString expression = settings.value( QStringLiteral( "expression" ) ).toString();
640 const QString helpText = settings.value( QStringLiteral( "helpText" ) ).toString();
641 const QJsonObject expressionObject
642 {
643 {"name", label},
644 {"type", "expression"},
645 {"expression", expression},
646 {"group", group},
647 {"description", helpText}
648 };
649 exportList.push_back( expressionObject );
650
651 settings.endGroup();
652 }
653
654 exportObject[QStringLiteral( "expressions" )] = exportList;
655 QJsonDocument exportJson = QJsonDocument( exportObject );
656
657 return exportJson;
658}
659
660void QgsExpressionTreeView::loadExpressionsFromJson( const QJsonDocument &expressionsDocument )
661{
662 // if the root of the json document is not an object, it means it's a wrong file
663 if ( ! expressionsDocument.isObject() )
664 return;
665
666 QJsonObject expressionsObject = expressionsDocument.object();
667
668 // validate json for manadatory fields
669 if ( ! expressionsObject[QStringLiteral( "qgis_version" )].isString()
670 || ! expressionsObject[QStringLiteral( "exported_at" )].isString()
671 || ! expressionsObject[QStringLiteral( "author" )].isString()
672 || ! expressionsObject[QStringLiteral( "expressions" )].isArray() )
673 return;
674
675 // validate versions
676 QVersionNumber qgisJsonVersion = QVersionNumber::fromString( expressionsObject[QStringLiteral( "qgis_version" )].toString() );
677 QVersionNumber qgisVersion = QVersionNumber::fromString( Qgis::version() );
678
679 // if the expressions are from newer version of QGIS, we ask the user to confirm
680 // they want to proceed
681 if ( qgisJsonVersion > qgisVersion )
682 {
683 QMessageBox::StandardButtons buttons = QMessageBox::Yes | QMessageBox::No;
684 switch ( QMessageBox::question( this,
685 tr( "QGIS Version Mismatch" ),
686 tr( "The imported expressions are from newer version of QGIS (%1) "
687 "and some of the expression might not work the current version (%2). "
688 "Are you sure you want to continue?" ).arg( qgisJsonVersion.toString(), qgisVersion.toString() ), buttons ) )
689 {
690 case QMessageBox::No:
691 return;
692
693 case QMessageBox::Yes:
694 break;
695
696 default:
697 break;
698 }
699 }
700
701 // we store the number of
702 QStringList skippedExpressionLabels;
703 bool isApplyToAll = false;
704 bool isOkToOverwrite = false;
705
706 QgsSettings settings;
707 settings.beginGroup( QStringLiteral( "user" ), QgsSettings::Section::Expressions );
708 mUserExpressionLabels = settings.childGroups();
709
710 const QJsonArray expressions = expressionsObject[QStringLiteral( "expressions" )].toArray();
711 for ( const QJsonValue && expressionValue : expressions )
712 {
713 // validate the type of the array element, can be anything
714 if ( ! expressionValue.isObject() )
715 {
716 // try to stringify and put and indicator what happened
717 skippedExpressionLabels.append( expressionValue.toString() );
718 continue;
719 }
720
721 QJsonObject expressionObj = expressionValue.toObject();
722
723 // make sure the required keys are the correct types
724 if ( ! expressionObj[QStringLiteral( "name" )].isString()
725 || ! expressionObj[QStringLiteral( "type" )].isString()
726 || ! expressionObj[QStringLiteral( "expression" )].isString()
727 || ! expressionObj[QStringLiteral( "group" )].isString()
728 || ! expressionObj[QStringLiteral( "description" )].isString() )
729 {
730 // try to stringify and put an indicator what happened. Try to stringify the name, if fails, go with the expression.
731 if ( ! expressionObj[QStringLiteral( "name" )].toString().isEmpty() )
732 skippedExpressionLabels.append( expressionObj[QStringLiteral( "name" )].toString() );
733 else
734 skippedExpressionLabels.append( expressionObj[QStringLiteral( "expression" )].toString() );
735
736 continue;
737 }
738
739 // we want to import only items of type expression for now
740 if ( expressionObj[QStringLiteral( "type" )].toString() != QLatin1String( "expression" ) )
741 {
742 skippedExpressionLabels.append( expressionObj[QStringLiteral( "name" )].toString() );
743 continue;
744 }
745
746 // we want to import only items of type expression for now
747 if ( expressionObj[QStringLiteral( "group" )].toString() != QLatin1String( "user" ) )
748 {
749 skippedExpressionLabels.append( expressionObj[QStringLiteral( "name" )].toString() );
750 continue;
751 }
752
753 const QString label = expressionObj[QStringLiteral( "name" )].toString();
754 const QString expression = expressionObj[QStringLiteral( "expression" )].toString();
755 const QString helpText = expressionObj[QStringLiteral( "description" )].toString();
756
757 // make sure they have valid name
758 if ( label.contains( QLatin1String( "\\" ) ) || label.contains( '/' ) )
759 {
760 skippedExpressionLabels.append( expressionObj[QStringLiteral( "name" )].toString() );
761 continue;
762 }
763
764 settings.beginGroup( label );
765 const QString oldExpression = settings.value( QStringLiteral( "expression" ) ).toString();
766 settings.endGroup();
767
768 // TODO would be nice to skip the cases when labels and expressions match
769 if ( mUserExpressionLabels.contains( label ) && expression != oldExpression )
770 {
771 if ( ! isApplyToAll )
772 showMessageBoxConfirmExpressionOverwrite( isApplyToAll, isOkToOverwrite, label, oldExpression, expression );
773
774 if ( isOkToOverwrite )
775 saveToUserExpressions( label, expression, helpText );
776 else
777 {
778 skippedExpressionLabels.append( label );
779 continue;
780 }
781 }
782 else
783 {
784 saveToUserExpressions( label, expression, helpText );
785 }
786 }
787
789
790 if ( ! skippedExpressionLabels.isEmpty() )
791 {
792 QStringList skippedExpressionLabelsQuoted;
793 skippedExpressionLabelsQuoted.reserve( skippedExpressionLabels.size() );
794 for ( const QString &skippedExpressionLabel : skippedExpressionLabels )
795 skippedExpressionLabelsQuoted.append( QStringLiteral( "'%1'" ).arg( skippedExpressionLabel ) );
796
797 QMessageBox::information( this,
798 tr( "Skipped Expression Imports" ),
799 QStringLiteral( "%1\n%2" ).arg( tr( "The following expressions have been skipped:" ),
800 skippedExpressionLabelsQuoted.join( QLatin1String( ", " ) ) ) );
801 }
802}
803
804const QList<QgsExpressionItem *> QgsExpressionTreeView::findExpressions( const QString &label )
805{
806 QList<QgsExpressionItem *> result;
807 const QList<QStandardItem *> found { mModel->findItems( label, Qt::MatchFlag::MatchRecursive ) };
808 result.reserve( found.size() );
809 std::transform( found.begin(), found.end(), std::back_inserter( result ),
810 []( QStandardItem * item ) -> QgsExpressionItem* { return static_cast<QgsExpressionItem *>( item ); } );
811 return result;
812}
813
814void QgsExpressionTreeView::showMessageBoxConfirmExpressionOverwrite(
815 bool &isApplyToAll,
816 bool &isOkToOverwrite,
817 const QString &label,
818 const QString &oldExpression,
819 const QString &newExpression )
820{
821 QMessageBox::StandardButtons buttons = QMessageBox::Yes | QMessageBox::YesToAll | QMessageBox::No | QMessageBox::NoToAll;
822 switch ( QMessageBox::question( this,
823 tr( "Expression Overwrite" ),
824 tr( "The expression with label '%1' was already defined."
825 "The old expression \"%2\" will be overwritten by \"%3\"."
826 "Are you sure you want to overwrite the expression?" ).arg( label, oldExpression, newExpression ), buttons ) )
827 {
828 case QMessageBox::NoToAll:
829 isApplyToAll = true;
830 isOkToOverwrite = false;
831 break;
832
833 case QMessageBox::No:
834 isApplyToAll = false;
835 isOkToOverwrite = false;
836 break;
837
838 case QMessageBox::YesToAll:
839 isApplyToAll = true;
840 isOkToOverwrite = true;
841 break;
842
843 case QMessageBox::Yes:
844 isApplyToAll = false;
845 isOkToOverwrite = true;
846 break;
847
848 default:
849 break;
850 }
851}
852
853
854// ****************************
855// ****************************
856// QgsExpressionItemSearchProxy
857// ****************************
858
859
861{
862 setFilterCaseSensitivity( Qt::CaseInsensitive );
863}
864
865bool QgsExpressionItemSearchProxy::filterAcceptsRow( int source_row, const QModelIndex &source_parent ) const
866{
867 QModelIndex index = sourceModel()->index( source_row, 0, source_parent );
868 const QgsExpressionItem::ItemType itemType = QgsExpressionItem::ItemType( sourceModel()->data( index, QgsExpressionItem::ITEM_TYPE_ROLE ).toInt() );
869
870 if ( itemType == QgsExpressionItem::Header )
871 {
872 // show header if any child item matches
873 int count = sourceModel()->rowCount( index );
874 bool matchchild = false;
875 for ( int i = 0; i < count; ++i )
876 {
877 if ( filterAcceptsRow( i, index ) )
878 {
879 matchchild = true;
880 break;
881 }
882 }
883 return matchchild;
884 }
885
886 // check match of item label or tags
887 const QString name = sourceModel()->data( index, Qt::DisplayRole ).toString();
888 if ( name.contains( mFilterString, Qt::CaseInsensitive ) )
889 {
890 return true;
891 }
892
893 const QStringList tags = sourceModel()->data( index, QgsExpressionItem::SEARCH_TAGS_ROLE ).toStringList();
894 return std::any_of( tags.begin(), tags.end(), [this]( const QString & tag )
895 {
896 return tag.contains( mFilterString, Qt::CaseInsensitive );
897 } );
898}
899
901{
902 mFilterString = string;
903 invalidate();
904}
905
906bool QgsExpressionItemSearchProxy::lessThan( const QModelIndex &left, const QModelIndex &right ) const
907{
908 int leftSort = sourceModel()->data( left, QgsExpressionItem::CUSTOM_SORT_ROLE ).toInt();
909 int rightSort = sourceModel()->data( right, QgsExpressionItem::CUSTOM_SORT_ROLE ).toInt();
910 if ( leftSort != rightSort )
911 return leftSort < rightSort;
912
913 QString leftString = sourceModel()->data( left, Qt::DisplayRole ).toString();
914 QString rightString = sourceModel()->data( right, Qt::DisplayRole ).toString();
915
916 //ignore $ prefixes when sorting
917 if ( leftString.startsWith( '$' ) )
918 leftString = leftString.mid( 1 );
919 if ( rightString.startsWith( '$' ) )
920 rightString = rightString.mid( 1 );
921
922 return QString::localeAwareCompare( leftString, rightString ) < 0;
923}
static QString version()
Version string.
Definition qgis.cpp:259
static QString userFullName()
Returns the user's operating system login account full display name.
static QgsExpressionContextScope * layerScope(const QgsMapLayer *layer)
Creates a new scope which contains variables and functions relating to a QgsMapLayer.
Expression contexts are used to encapsulate the parameters around which a QgsExpression should be eva...
QString description(const QString &name) const
Returns a translated description string for the variable with specified name.
QStringList functionNames() const
Retrieves a list of function names contained in the context.
bool isHighlightedFunction(const QString &name) const
Returns true if the specified function name is intended to be highlighted to the user.
QStringList filteredVariableNames() const
Returns a filtered list of variables names set by all scopes in the context.
bool isHighlightedVariable(const QString &name) const
Returns true if the specified variable name is intended to be highlighted to the user.
QgsExpressionFunction * function(const QString &name) const
Fetches a matching function from the context.
QVariant variable(const QString &name) const
Fetches a matching variable from the context.
A abstract base class for defining QgsExpression functions.
bool isContextual() const
Returns whether the function is only available if provided by a QgsExpressionContext object.
int params() const
The number of parameters this function takes.
QStringList groups() const
Returns a list of the groups the function belongs to.
virtual bool isDeprecated() const
Returns true if the function is deprecated and should not be presented as a valid option to users in ...
QString name() const
The name of the function.
const QString helpText() const
The help text for the function.
bool filterAcceptsRow(int source_row, const QModelIndex &source_parent) const override
void setFilterString(const QString &string)
Sets the search filter string.
bool lessThan(const QModelIndex &left, const QModelIndex &right) const override
An expression item that can be used in the QgsExpressionBuilderWidget tree.
static const int LAYER_ID_ROLE
Layer ID role.
QString getExpressionText() const
static const int SEARCH_TAGS_ROLE
Search tags role.
static const int ITEM_TYPE_ROLE
Item type role.
static const int CUSTOM_SORT_ROLE
Custom sort order role.
QgsExpressionItem::ItemType getItemType() const
Gets the type of expression item, e.g., header, field, ExpressionNode.
static const int ITEM_NAME_ROLE
Item name role.
Implementation of this interface can be implemented to allow QgsExpressionTreeView instance to provid...
virtual QMenu * createContextMenu(QgsExpressionItem *item)
Returns a newly created menu instance.
QgsProject * project()
Returns the project currently associated with the widget.
void refresh()
Refreshes the content of the tree.
void setProject(QgsProject *project)
Sets the project currently associated with the widget.
void saveToUserExpressions(const QString &label, const QString &expression, const QString &helpText)
Stores the user expression with given label and helpText.
QgsExpressionItem * currentItem() const
Returns the current item or a nullptr.
void setLayer(QgsVectorLayer *layer)
Sets layer in order to get the fields and values.
void setMenuProvider(MenuProvider *provider)
Sets the menu provider.
QStringList userExpressionLabels() const
Returns the user expression labels.
void expressionItemDoubleClicked(const QString &text)
Emitted when a expression item is double clicked.
void currentExpressionItemChanged(QgsExpressionItem *item)
Emitter when the current expression item changed.
QJsonDocument exportUserExpressions()
Create the expressions JSON document storing all the user expressions to be exported.
QgsExpressionTreeView(QWidget *parent=nullptr)
Constructor.
void loadExpressionsFromJson(const QJsonDocument &expressionsDocument)
Load and permanently store the expressions from the expressions JSON document.
void saveToRecent(const QString &expressionText, const QString &collection="generic")
Adds the current expression to the given collection.
void setSearchText(const QString &text)
Sets the text to filter the expression tree.
void setExpressionContext(const QgsExpressionContext &context)
Sets the expression context for the tree view.
const QList< QgsExpressionItem * > findExpressions(const QString &label)
Returns the list of expression items matching a label.
void removeFromUserExpressions(const QString &label)
Removes the expression label from the user stored expressions.
void loadRecent(const QString &collection=QStringLiteral("generic"))
Loads the recent expressions from the given collection.
void loadUserExpressions()
Loads the user expressions.
Q_DECL_DEPRECATED QStandardItemModel * model()
Returns a pointer to the dialog's function item model.
void loadFieldNames(const QgsFields &fields)
This allows loading fields without specifying a layer.
static const QList< QgsExpressionFunction * > & Functions()
static int functionCount()
Returns the number of functions defined in the parser.
static QString variableHelpText(const QString &variableName)
Returns the help text for a specified variable.
static QString formatPreviewString(const QVariant &value, bool htmlOutput=true, int maximumPreviewLength=60)
Formats an expression result for friendly display to the user.
static QStringList tags(const QString &name)
Returns a string list of search tags for a specified function.
static QString group(const QString &group)
Returns the translated name for a function group.
Encapsulate a field in an attribute table or data source.
Definition qgsfield.h:53
QString name
Definition qgsfield.h:62
QString displayNameWithAlias() const
Returns the name to use when displaying this field and adds the alias in parenthesis if it is defined...
Definition qgsfield.cpp:103
Container of fields for a vector layer.
Definition qgsfields.h:46
int count
Definition qgsfields.h:50
QgsField at(int i) const
Returns the field at particular index (must be in range 0..N-1).
QIcon iconForField(int fieldIdx, bool considerOrigin=false) const
Returns an icon corresponding to a field index, based on the field's type and source.
static QIcon iconForLayer(const QgsMapLayer *layer)
Returns the icon corresponding to a specified map layer.
Base class for all map layer types.
Definition qgsmaplayer.h:76
QString name
Definition qgsmaplayer.h:80
QString id
Definition qgsmaplayer.h:79
Encapsulates a QGIS project, including sets of map layers and their styles, layouts,...
Definition qgsproject.h:107
Represents a relationship between two vector layers.
Definition qgsrelation.h:44
QString name
Definition qgsrelation.h:50
QString id
Definition qgsrelation.h:47
This class is a composition of two QSettings instances:
Definition qgssettings.h:64
QStringList childGroups(Qgis::SettingsOrigin origin=Qgis::SettingsOrigin::Any) const
Returns a list of all key top-level groups that contain keys that can be read using the QSettings obj...
void endGroup()
Resets the group to what it was before the corresponding beginGroup() call.
QVariant value(const QString &key, const QVariant &defaultValue=QVariant(), Section section=NoSection) const
Returns the value for setting key.
void beginGroup(const QString &prefix, QgsSettings::Section section=QgsSettings::NoSection)
Appends prefix to the current group.
void remove(const QString &key, QgsSettings::Section section=QgsSettings::NoSection)
Removes the setting key and any sub-settings of key in a section.
void setValue(const QString &key, const QVariant &value, QgsSettings::Section section=QgsSettings::NoSection)
Sets the value of setting key to value.
Represents a vector layer which manages a vector based data sets.
QString formatLayerHelp(const QgsMapLayer *layer)
Returns a HTML formatted string for use as a layer item help.
QString formatUserExpressionHelp(const QString &label, const QString &expression, const QString &description)
Returns a HTML formatted string for use as a user expression item help.
QString formatVariableHelp(const QString &variable, const QString &description, bool showValue, const QVariant &value)
Returns a HTML formatted string for use as a variable item help.
QString formatRecentExpressionHelp(const QString &label, const QString &expression)
Returns a HTML formatted string for use as a recent expression item help.
QString formatRelationHelp(const QgsRelation &relation)
Returns a HTML formatted string for use as a relation item help.