QGIS API Documentation 3.43.0-Master (9e873c7bc91)
Loading...
Searching...
No Matches
qgsbrowserwidget.cpp
Go to the documentation of this file.
1/***************************************************************************
2 qgsbrowserwidget.cpp
3 ---------------------
4 begin : July 2011
5 copyright : (C) 2011 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#include "qgsbrowserwidget.h"
16#include "moc_qgsbrowserwidget.cpp"
17
18#include <QAbstractTextDocumentLayout>
19#include <QHeaderView>
20#include <QTreeView>
21#include <QMenu>
22#include <QToolButton>
23#include <QFileDialog>
24#include <QPlainTextDocumentLayout>
25#include <QSortFilterProxyModel>
26#include <QActionGroup>
27
28#include "qgsbrowserguimodel.h"
29#include "qgsbrowsertreeview.h"
30#include "qgslogger.h"
31#include "qgsrasterlayer.h"
32#include "qgsvectorlayer.h"
33#include "qgsproject.h"
34#include "qgssettings.h"
35#include "qgsnewnamedialog.h"
37#include "qgsgui.h"
39#include "qgsnative.h"
42#include "qgsdirectoryitem.h"
43#include "qgslayeritem.h"
44#include "qgsprojectitem.h"
46
47// browser layer properties dialog
48#include "qgsapplication.h"
49#include "qgsmapcanvas.h"
50
51#include <QDragEnterEvent>
52#include <functional>
53
55 : QgsPanelWidget( parent )
56 , mModel( browserModel )
57{
58 setupUi( this );
59
60 layout()->setContentsMargins( 0, 0, 0, 0 );
61 qgis::down_cast<QVBoxLayout *>( layout() )->setSpacing( 0 );
62
63 mBrowserView = new QgsDockBrowserTreeView( this );
64 mLayoutBrowser->addWidget( mBrowserView );
65
66 mWidgetFilter->hide();
67 mLeFilter->setPlaceholderText( tr( "Type here to filter visible items…" ) );
68 // icons from http://www.fatcow.com/free-icons License: CC Attribution 3.0
69
70 QMenu *menu = new QMenu( this );
71 menu->setSeparatorsCollapsible( false );
72 mBtnFilterOptions->setMenu( menu );
73 QAction *action = new QAction( tr( "Case Sensitive" ), menu );
74 action->setData( "case" );
75 action->setCheckable( true );
76 action->setChecked( false );
77 connect( action, &QAction::toggled, this, &QgsBrowserWidget::setCaseSensitive );
78 menu->addAction( action );
79 QActionGroup *group = new QActionGroup( menu );
80 action = new QAction( tr( "Filter Pattern Syntax" ), group );
81 action->setSeparator( true );
82 menu->addAction( action );
83 action = new QAction( tr( "Normal" ), group );
84 action->setData( QgsBrowserProxyModel::Normal );
85 action->setCheckable( true );
86 action->setChecked( true );
87 menu->addAction( action );
88 action = new QAction( tr( "Wildcard(s)" ), group );
89 action->setData( QgsBrowserProxyModel::Wildcards );
90 action->setCheckable( true );
91 menu->addAction( action );
92 action = new QAction( tr( "Regular Expression" ), group );
94 action->setCheckable( true );
95 menu->addAction( action );
96
97 mBrowserView->setExpandsOnDoubleClick( false );
98
99 connect( mActionRefresh, &QAction::triggered, this, &QgsBrowserWidget::refresh );
100 connect( mActionAddLayers, &QAction::triggered, this, &QgsBrowserWidget::addSelectedLayers );
101 connect( mActionCollapse, &QAction::triggered, mBrowserView, &QgsDockBrowserTreeView::collapseAll );
102 connect( mActionShowFilter, &QAction::triggered, this, &QgsBrowserWidget::showFilterWidget );
103 connect( mActionPropertiesWidget, &QAction::triggered, this, &QgsBrowserWidget::propertiesWidgetToggled );
104 connect( mLeFilter, &QgsFilterLineEdit::returnPressed, this, &QgsBrowserWidget::setFilter );
105 connect( mLeFilter, &QgsFilterLineEdit::cleared, this, &QgsBrowserWidget::setFilter );
106 connect( mLeFilter, &QgsFilterLineEdit::textChanged, this, &QgsBrowserWidget::setFilter );
107 connect( group, &QActionGroup::triggered, this, &QgsBrowserWidget::setFilterSyntax );
108 connect( mBrowserView, &QgsDockBrowserTreeView::customContextMenuRequested, this, &QgsBrowserWidget::showContextMenu );
109 connect( mBrowserView, &QgsDockBrowserTreeView::doubleClicked, this, &QgsBrowserWidget::itemDoubleClicked );
110 connect( mSplitter, &QSplitter::splitterMoved, this, &QgsBrowserWidget::splitterMoved );
111
112 connect( QgsGui::instance(), &QgsGui::optionsChanged, this, &QgsBrowserWidget::onOptionsChanged );
113}
114
116
117void QgsBrowserWidget::showEvent( QShowEvent *e )
118{
119 // delayed initialization of the model
120 if ( !mModel->initialized() )
121 {
122 mModel->initialize();
123 }
124 if ( !mProxyModel )
125 {
126 mProxyModel = new QgsBrowserProxyModel( this );
127 mProxyModel->setBrowserModel( mModel );
128 mProxyModel->setHiddenDataItemProviderKeyFilter( mDisabledDataItemsKeys );
129 mBrowserView->setSettingsSection( objectName().toLower() ); // to distinguish 2 or more instances of the browser
130 mBrowserView->setBrowserModel( mModel );
131 mBrowserView->setModel( mProxyModel );
132 mBrowserView->setSortingEnabled( true );
133 mBrowserView->sortByColumn( 0, Qt::AscendingOrder );
134 // provide a horizontal scroll bar instead of using ellipse (...) for longer items
135 mBrowserView->setTextElideMode( Qt::ElideNone );
136 mBrowserView->header()->setSectionResizeMode( 0, QHeaderView::ResizeToContents );
137 mBrowserView->header()->setStretchLastSection( false );
138
139 // selectionModel is created when model is set on tree
140 connect( mBrowserView->selectionModel(), &QItemSelectionModel::selectionChanged, this, &QgsBrowserWidget::selectionChanged );
141
142 // Forward the model changed signals to the widget
144
145 // objectName used by settingsSection() is not yet set in constructor
146 QgsSettings settings;
147 mActionPropertiesWidget->setChecked( settings.value( settingsSection() + "/propertiesWidgetEnabled", false ).toBool() );
148 mPropertiesWidget->setVisible( false ); // false until item is selected
149
150 mSplitter->restoreState( settings.value( QStringLiteral( "%1/splitterState" ).arg( settingsSection() ) ).toByteArray() );
151 }
152
153 QWidget::showEvent( e );
154}
155
156void QgsBrowserWidget::itemDoubleClicked( const QModelIndex &index )
157{
158 QgsDataItem *item = mModel->dataItem( mProxyModel->mapToSource( index ) );
159 if ( !item )
160 return;
161
162 QgsDataItemGuiContext context = createContext();
163
164 const QList<QgsDataItemGuiProvider *> providers = QgsGui::dataItemGuiProviderRegistry()->providers();
165 for ( QgsDataItemGuiProvider *provider : providers )
166 {
167 if ( provider->handleDoubleClick( item, context ) )
168 return;
169 }
170
171 // if no providers overrode the double-click handling for this item, we give the item itself a chance
172 if ( !item->handleDoubleClick() )
173 {
174 // double-click not handled by browser model, so use as default view expand behavior
175 if ( mBrowserView->isExpanded( index ) )
176 mBrowserView->collapse( index );
177 else
178 mBrowserView->expand( index );
179 }
180}
181
182void QgsBrowserWidget::onOptionsChanged()
183{
184 std::function<void( const QModelIndex &index )> updateItem;
185 updateItem = [this, &updateItem]( const QModelIndex &index ) {
186 if ( QgsDirectoryItem *dirItem = qobject_cast<QgsDirectoryItem *>( mModel->dataItem( index ) ) )
187 {
188 dirItem->reevaluateMonitoring();
189 }
190
191 const int rowCount = mModel->rowCount( index );
192 for ( int i = 0; i < rowCount; ++i )
193 {
194 const QModelIndex child = mModel->index( i, 0, index );
195 updateItem( child );
196 }
197 };
198
199 for ( int i = 0; i < mModel->rowCount(); ++i )
200 {
201 updateItem( mModel->index( i, 0 ) );
202 }
203}
204
205void QgsBrowserWidget::showContextMenu( QPoint pt )
206{
207 QModelIndex index = mProxyModel->mapToSource( mBrowserView->indexAt( pt ) );
208 QgsDataItem *item = mModel->dataItem( index );
209 if ( !item )
210 return;
211
212 const QModelIndexList selection = mBrowserView->selectionModel()->selectedIndexes();
213 QList<QgsDataItem *> selectedItems;
214 selectedItems.reserve( selection.size() );
215 for ( const QModelIndex &selectedIndex : selection )
216 {
217 QgsDataItem *selectedItem = mProxyModel->dataItem( selectedIndex );
218 if ( selectedItem )
219 selectedItems << selectedItem;
220 }
221
222 QMenu *menu = new QMenu( this );
223
224 const QList<QMenu *> menus = item->menus( menu );
225 QList<QAction *> actions = item->actions( menu );
226
227 if ( !menus.isEmpty() )
228 {
229 for ( QMenu *mn : menus )
230 {
231 menu->addMenu( mn );
232 }
233 }
234
235 if ( !actions.isEmpty() )
236 {
237 if ( !menu->actions().isEmpty() )
238 menu->addSeparator();
239 // add action to the menu
240 menu->addActions( actions );
241 }
242
243 QgsDataItemGuiContext context = createContext();
244
245 QList<QgsDataItemGuiProvider *> providers = QgsGui::dataItemGuiProviderRegistry()->providers();
246 std::sort( providers.begin(), providers.end(), []( QgsDataItemGuiProvider *a, QgsDataItemGuiProvider *b ) {
247 return a->precedenceWhenPopulatingMenus() < b->precedenceWhenPopulatingMenus();
248 } );
249 for ( QgsDataItemGuiProvider *provider : std::as_const( providers ) )
250 {
251 provider->populateContextMenu( item, menu, selectedItems, context );
252 }
253
254 if ( menu->actions().isEmpty() )
255 {
256 delete menu;
257 return;
258 }
259
260 menu->popup( mBrowserView->mapToGlobal( pt ) );
261}
262
264{
265 mMessageBar = bar;
266 mModel->setMessageBar( bar );
267}
268
270{
271 return mMessageBar;
272}
273
275{
276 mMapCanvas = canvas;
277 mModel->setMapCanvas( canvas );
278}
279
281{
282 return mMapCanvas;
283}
284
285void QgsBrowserWidget::setDisabledDataItemsKeys( const QStringList &filter )
286{
287 mDisabledDataItemsKeys = filter;
288
289 if ( !mProxyModel )
290 return;
291
292 mProxyModel->setHiddenDataItemProviderKeyFilter( mDisabledDataItemsKeys );
293}
294
296{
297 refreshModel( QModelIndex() );
298}
299
300void QgsBrowserWidget::refreshModel( const QModelIndex &index )
301{
302 if ( mModel && mProxyModel )
303 {
304 QgsDataItem *item = mModel->dataItem( index );
305 if ( item )
306 {
307 QgsDebugMsgLevel( "path = " + item->path(), 4 );
308 }
309 else
310 {
311 QgsDebugMsgLevel( QStringLiteral( "invalid item" ), 4 );
312 }
313
314 if ( item && ( item->capabilities2() & Qgis::BrowserItemCapability::Fertile ) )
315 {
316 mModel->refresh( index );
317 }
318
319 for ( int i = 0; i < mModel->rowCount( index ); i++ )
320 {
321 QModelIndex idx = mModel->index( i, 0, index );
322 QModelIndex proxyIdx = mProxyModel->mapFromSource( idx );
323 QgsDataItem *child = mModel->dataItem( idx );
324
325 // Check also expanded descendants so that the whole expanded path does not get collapsed if one item is collapsed.
326 // Fast items (usually root items) are refreshed so that when collapsed, it is obvious they are if empty (no expand symbol).
327 if ( mBrowserView->isExpanded( proxyIdx ) || mBrowserView->hasExpandedDescendant( proxyIdx ) || ( child && child->capabilities2() & Qgis::BrowserItemCapability::Fast ) )
328 {
329 refreshModel( idx );
330 }
331 else
332 {
333 if ( child && ( child->capabilities2() & Qgis::BrowserItemCapability::Fertile ) )
334 {
335 child->depopulate();
336 }
337 }
338 }
339 }
340}
341
342void QgsBrowserWidget::addLayer( QgsLayerItem *layerItem )
343{
344 if ( !layerItem )
345 return;
346
347 emit handleDropUriList( layerItem->mimeUris() );
348}
349
350void QgsBrowserWidget::addSelectedLayers()
351{
352 QApplication::setOverrideCursor( Qt::WaitCursor );
353
354 // get a sorted list of selected indexes
355 QModelIndexList list = mBrowserView->selectionModel()->selectedIndexes();
356 std::sort( list.begin(), list.end() );
357
358 // If any of the layer items are QGIS we just open and exit the loop
359 const auto constList = list;
360 for ( const QModelIndex &index : constList )
361 {
362 QgsDataItem *item = mModel->dataItem( mProxyModel->mapToSource( index ) );
363 if ( item && item->type() == Qgis::BrowserItemType::Project )
364 {
365 QgsProjectItem *projectItem = qobject_cast<QgsProjectItem *>( item );
366 if ( projectItem )
367 emit openFile( projectItem->path(), QStringLiteral( "project" ) );
368
369 QApplication::restoreOverrideCursor();
370 return;
371 }
372 }
373
374 // add items in reverse order so they are in correct order in the layers dock
375 for ( int i = list.size() - 1; i >= 0; i-- )
376 {
377 QgsDataItem *item = mModel->dataItem( mProxyModel->mapToSource( list[i] ) );
378 if ( item && item->type() == Qgis::BrowserItemType::Layer )
379 {
380 QgsLayerItem *layerItem = qobject_cast<QgsLayerItem *>( item );
381 if ( layerItem )
382 addLayer( layerItem );
383 }
384 }
385
386 QApplication::restoreOverrideCursor();
387}
388
389void QgsBrowserWidget::hideItem()
390{
391 QModelIndex index = mProxyModel->mapToSource( mBrowserView->currentIndex() );
392 QgsDataItem *item = mModel->dataItem( index );
393 if ( !item )
394 return;
395
396 if ( item->type() == Qgis::BrowserItemType::Directory )
397 {
398 mModel->hidePath( item );
399 }
400}
401
402void QgsBrowserWidget::showProperties()
403{
404 QModelIndex index = mProxyModel->mapToSource( mBrowserView->currentIndex() );
405 QgsDataItem *item = mModel->dataItem( index );
406 if ( !item )
407 return;
408
410 {
411 QgsBrowserPropertiesDialog *dialog = new QgsBrowserPropertiesDialog( settingsSection(), this );
412 dialog->setAttribute( Qt::WA_DeleteOnClose );
413 dialog->setItem( item, createContext() );
414 dialog->show();
415 }
416}
417
418void QgsBrowserWidget::showFilterWidget( bool visible )
419{
420 mWidgetFilter->setVisible( visible );
421 if ( !visible )
422 {
423 mLeFilter->setText( QString() );
424 setFilter();
425 }
426 else
427 {
428 mLeFilter->setFocus();
429 }
430}
431
432void QgsBrowserWidget::setFilter()
433{
434 QString filter = mLeFilter->text();
435 if ( mProxyModel )
436 mProxyModel->setFilterString( filter );
437}
438
440{
441 if ( mModel )
442 mModel->updateProjectHome();
443}
444
445void QgsBrowserWidget::setFilterSyntax( QAction *action )
446{
447 if ( !action || !mProxyModel )
448 return;
449
450 mProxyModel->setFilterSyntax( static_cast<QgsBrowserProxyModel::FilterSyntax>( action->data().toInt() ) );
451}
452
453void QgsBrowserWidget::setCaseSensitive( bool caseSensitive )
454{
455 if ( !mProxyModel )
456 return;
457 mProxyModel->setFilterCaseSensitivity( caseSensitive ? Qt::CaseSensitive : Qt::CaseInsensitive );
458}
459
460int QgsBrowserWidget::selectedItemsCount()
461{
462 QItemSelectionModel *selectionModel = mBrowserView->selectionModel();
463 if ( selectionModel )
464 {
465 return selectionModel->selectedIndexes().size();
466 }
467 return 0;
468}
469
470QgsDataItemGuiContext QgsBrowserWidget::createContext()
471{
472 QgsDataItemGuiContext context;
473 context.setMessageBar( mMessageBar );
474 context.setMapCanvas( mMapCanvas );
475 context.setView( mBrowserView );
476 return context;
477}
478
479void QgsBrowserWidget::selectionChanged( const QItemSelection &selected, const QItemSelection &deselected )
480{
481 Q_UNUSED( selected )
482 Q_UNUSED( deselected )
483 if ( mActionPropertiesWidget->isChecked() )
484 {
485 setPropertiesWidget();
486 }
487}
488
489void QgsBrowserWidget::clearPropertiesWidget()
490{
491 while ( mPropertiesLayout->count() > 0 )
492 {
493 delete mPropertiesLayout->itemAt( 0 )->widget();
494 }
495 mPropertiesWidget->setVisible( false );
496}
497
498void QgsBrowserWidget::setPropertiesWidget()
499{
500 clearPropertiesWidget();
501 QItemSelectionModel *selectionModel = mBrowserView->selectionModel();
502 if ( selectionModel )
503 {
504 QModelIndexList indexes = selectionModel->selectedIndexes();
505 if ( indexes.size() == 1 )
506 {
507 QModelIndex index = mProxyModel->mapToSource( indexes.value( 0 ) );
508 QgsDataItem *item = mModel->dataItem( index );
509 QgsDataItemGuiContext context = createContext();
510 QgsBrowserPropertiesWidget *propertiesWidget = QgsBrowserPropertiesWidget::createWidget( item, context, mPropertiesWidget );
511 if ( propertiesWidget )
512 {
513 propertiesWidget->setCondensedMode( true );
514 mPropertiesLayout->addWidget( propertiesWidget );
515 }
516 }
517 }
518 mPropertiesWidget->setVisible( mPropertiesLayout->count() > 0 );
519}
520
521void QgsBrowserWidget::enablePropertiesWidget( bool enable )
522{
523 mActionPropertiesWidget->setChecked( enable );
524 propertiesWidgetToggled( enable );
525}
526
527void QgsBrowserWidget::propertiesWidgetToggled( bool enabled )
528{
529 if ( enabled && selectedItemsCount() == 1 )
530 {
531 setPropertiesWidget();
532 }
533 else
534 {
535 clearPropertiesWidget();
536 }
537
538 QgsSettings settings;
539 settings.setValue( settingsSection() + "/propertiesWidgetEnabled", enabled );
540}
541
542void QgsBrowserWidget::setActiveIndex( const QModelIndex &index )
543{
544 if ( index.isValid() )
545 {
546 QModelIndex proxyIndex = mProxyModel->mapFromSource( index );
547 mBrowserView->expand( proxyIndex );
548 mBrowserView->setCurrentIndex( proxyIndex );
549 }
550}
551
552void QgsBrowserWidget::splitterMoved()
553{
554 QgsSettings settings;
555 settings.setValue( QStringLiteral( "%1/splitterState" ).arg( settingsSection() ), mSplitter->saveState() );
556}
@ Fertile
Can create children. Even items without this capability may have children, but cannot create them,...
@ Fast
CreateChildren() is fast enough to be run in main thread when refreshing items, most root items (wms,...
@ Layer
Represents a map layer.
@ Project
Represents a QGIS project.
@ Directory
Represents a file directory.
A model for showing available data sources and other items in a structured tree.
void setMapCanvas(QgsMapCanvas *canvas)
Sets the associated map canvas that will be passed in QgsDataItemGuiContext to data items.
void setMessageBar(QgsMessageBar *bar)
Sets message bar that will be passed in QgsDataItemGuiContext to data items.
void connectionsChanged(const QString &providerKey)
Emitted when connections for the specified providerKey have changed in the browser.
QgsDataItem * dataItem(const QModelIndex &idx) const
Returns the data item at the specified index, or nullptr if no item exists at the index.
void hidePath(QgsDataItem *item)
Hide the given path in the browser model.
void refresh(const QString &path)
Refresh item specified by path.
int rowCount(const QModelIndex &parent=QModelIndex()) const override
void initialize()
Delayed initialization, needed because the provider registry must be already populated.
QModelIndex index(int row, int column, const QModelIndex &parent=QModelIndex()) const override
bool initialized() const
Returns true if the model has been initialized.
A QSortFilterProxyModel subclass for filtering and sorting browser model items.
FilterSyntax
Filter syntax options.
@ RegularExpression
Regular expression filtering.
@ Wildcards
Wildcard filtering.
@ Normal
Standard string filtering.
void setHiddenDataItemProviderKeyFilter(const QStringList &hiddenItemsFilter)
Sets a filter to hide data items based on QgsDataItem::providerKey() associated with the item.
void setFilterString(const QString &filter)
Sets the filter string to use when filtering items in the model.
QgsDataItem * dataItem(const QModelIndex &index) const
Returns the data item at the specified proxy index, or nullptr if no item exists at the index.
void setFilterCaseSensitivity(Qt::CaseSensitivity sensitivity)
Sets whether item filtering should be case sensitive.
void setFilterSyntax(FilterSyntax syntax)
Sets the filter syntax.
void setBrowserModel(QgsBrowserModel *model)
Sets the underlying browser model.
QgsBrowserWidget(QgsBrowserGuiModel *browserModel, QWidget *parent=nullptr)
Constructor for QgsBrowserWidget.
void updateProjectHome()
Update project home directory.
void setActiveIndex(const QModelIndex &index)
Sets the selection to index and expands it.
QgsMessageBar * messageBar()
Returns the message bar associated with the widget.
void connectionsChanged()
Connections changed in the browser.
void handleDropUriList(const QgsMimeDataUtils::UriList &)
Emitted when drop uri list needs to be handled.
void showEvent(QShowEvent *event) override
QgsMapCanvas * mapCanvas()
Returns the map canvas associated with the widget.
void setMapCanvas(QgsMapCanvas *canvas)
Sets a map canvas to use alongside the widget.
~QgsBrowserWidget() override
void setMessageBar(QgsMessageBar *bar)
Sets a message bar to use alongside the widget.
void openFile(const QString &fileName, const QString &fileTypeHint=QString())
Emitted when a file needs to be opened.
void refresh()
Refreshes the browser model and view.
void setDisabledDataItemsKeys(const QStringList &filter)
Sets the customization for data items based on item's data provider key.
Encapsulates the context in which a QgsDataItem is shown within the application GUI.
void setView(QgsBrowserTreeView *view)
Sets the associated view.
void setMapCanvas(QgsMapCanvas *canvas)
Sets the map canvas associated with the data item.
void setMessageBar(QgsMessageBar *bar)
Sets the associated message bar.
QList< QgsDataItemGuiProvider * > providers() const
Returns the list of available providers.
Abstract base class for providers which affect how QgsDataItem items behave within the application GU...
Base class for all items in the model.
Definition qgsdataitem.h:46
virtual QList< QMenu * > menus(QWidget *parent)
Returns the list of menus available for this item.
virtual bool handleDoubleClick()
Called when a user double clicks on the item.
Qgis::BrowserItemType type() const
virtual QList< QAction * > actions(QWidget *parent)
Returns the list of actions available for this item.
QString path() const
virtual Qgis::BrowserItemCapabilities capabilities2() const
Returns the capabilities for the data item.
virtual void depopulate()
Remove children recursively and set as not populated. This is used when refreshing collapsed items.
A directory: contains subdirectories and layers.
void cleared()
Emitted when the widget is cleared.
void optionsChanged()
This signal is emitted whenever the application options have been changed.
static QgsGui * instance()
Returns a pointer to the singleton instance.
Definition qgsgui.cpp:79
static QgsDataItemGuiProviderRegistry * dataItemGuiProviderRegistry()
Returns the global data item GUI provider registry, used for tracking providers which affect the brow...
Definition qgsgui.cpp:180
Item that represents a layer that can be opened with one of the providers.
QgsMimeDataUtils::UriList mimeUris() const override
Returns mime URIs for the data item, most data providers will only return a single URI but some data ...
Map canvas is a class for displaying all GIS data types on a canvas.
A bar for displaying non-blocking messages to the user.
Base class for any widget that can be shown as a inline panel.
Data item that can be used to represent QGIS projects.
This class is a composition of two QSettings instances:
Definition qgssettings.h:64
QVariant value(const QString &key, const QVariant &defaultValue=QVariant(), Section section=NoSection) const
Returns the value for setting key.
void setValue(const QString &key, const QVariant &value, QgsSettings::Section section=QgsSettings::NoSection)
Sets the value of setting key to value.
#define QgsDebugMsgLevel(str, level)
Definition qgslogger.h:41