void QgsComposerPictureWidget::on_mRemoveDirectoryButton_clicked()
{
QString directoryToRemove = mSearchDirectoriesComboBox->currentText();
if ( directoryToRemove.isEmpty() )
{
return;
}
mSearchDirectoriesComboBox->removeItem( mSearchDirectoriesComboBox->currentIndex() );
//remove entries from back to front (to have the indices of existing items constant)
for ( int i = ( mPreviewListWidget->count() - 1 ); i >= 0; --i )
{
QListWidgetItem *currentItem = mPreviewListWidget->item( i );
if ( currentItem && currentItem->data( Qt::UserRole ).toString().startsWith( directoryToRemove ) )
{
delete ( mPreviewListWidget->takeItem( i ) );
}
}
//update the image directory list in the settings
QgsSettings s;
QStringList userDirList = s.value( QStringLiteral( "/Composer/PictureWidgetDirectories" ) ).toStringList();
userDirList.removeOne( directoryToRemove );
s.setValue( QStringLiteral( "/Composer/PictureWidgetDirectories" ), userDirList );
}
void QgsLocatorFiltersModel::commitChanges()
{
QgsSettings settings;
QHash< QgsLocatorFilter *, QString >::const_iterator itp = mPrefixes.constBegin();
for ( ; itp != mPrefixes.constEnd(); ++itp )
{
QgsLocatorFilter *filter = itp.key();
QString activePrefix = itp.value();
if ( !activePrefix.isEmpty() && activePrefix != filter->prefix() )
{
filter->setActivePrefix( activePrefix );
settings.setValue( QStringLiteral( "locator_filters/prefix_%1" ).arg( filter->name() ), activePrefix, QgsSettings::Section::Gui );
}
else
{
filter->setActivePrefix( QString() );
settings.remove( QStringLiteral( "locator_filters/prefix_%1" ).arg( filter->name() ), QgsSettings::Section::Gui );
}
}
QHash< QgsLocatorFilter *, bool >::const_iterator it = mEnabledChanges.constBegin();
for ( ; it != mEnabledChanges.constEnd(); ++it )
{
QgsLocatorFilter *filter = it.key();
settings.setValue( QStringLiteral( "locator_filters/enabled_%1" ).arg( filter->name() ), it.value(), QgsSettings::Section::Gui );
filter->setEnabled( it.value() );
}
it = mDefaultChanges.constBegin();
for ( ; it != mDefaultChanges.constEnd(); ++it )
{
QgsLocatorFilter *filter = it.key();
settings.setValue( QStringLiteral( "locator_filters/default_%1" ).arg( filter->name() ), it.value(), QgsSettings::Section::Gui );
filter->setUseWithoutPrefix( it.value() );
}
}
//! Autoconnected SLOTS *
void QgsNewOgrConnection::accept()
{
QgsSettings settings;
QString baseKey = '/' + cmbDatabaseTypes->currentText() + "/connections/";
settings.setValue( baseKey + "selected", txtName->text() );
// warn if entry was renamed to an existing connection
if ( ( mOriginalConnName.isNull() || mOriginalConnName != txtName->text() ) &&
settings.contains( baseKey + txtName->text() + "/host" ) &&
QMessageBox::question( this,
tr( "Save Connection" ),
tr( "Should the existing connection %1 be overwritten?" ).arg( txtName->text() ),
QMessageBox::Ok | QMessageBox::Cancel ) == QMessageBox::Cancel )
{
return;
}
// on rename delete original entry first
if ( !mOriginalConnName.isNull() && mOriginalConnName != txtName->text() )
{
settings.remove( baseKey + mOriginalConnName );
}
baseKey += txtName->text();
settings.setValue( baseKey + "/host", txtHost->text() );
settings.setValue( baseKey + "/database", txtDatabase->text() );
settings.setValue( baseKey + "/port", txtPort->text() );
settings.setValue( baseKey + "/username", mAuthSettingsDatabase->storeUsernameIsChecked() ? mAuthSettingsDatabase->username() : QLatin1String( "" ) );
settings.setValue( baseKey + "/password", mAuthSettingsDatabase->storePasswordIsChecked() ? mAuthSettingsDatabase->password() : QLatin1String( "" ) );
settings.setValue( baseKey + "/store_username", mAuthSettingsDatabase->storeUsernameIsChecked() ? "true" : "false" );
settings.setValue( baseKey + "/store_password", mAuthSettingsDatabase->storePasswordIsChecked() ? "true" : "false" );
settings.setValue( baseKey + "/configid", mAuthSettingsDatabase->configId() );
QDialog::accept();
}
bool QgsShortcutsManager::registerAction( QAction *action, const QString &defaultSequence )
{
if ( mActions.contains( action ) )
return false; // already registered
#ifdef QGISDEBUG
// if using a debug build, warn on duplicate actions
if ( actionByName( action->text() ) || shortcutByName( action->text() ) )
QgsLogger::warning( QStringLiteral( "Duplicate shortcut registered: %1" ).arg( action->text() ) );
#endif
mActions.insert( action, defaultSequence );
connect( action, &QObject::destroyed, this, &QgsShortcutsManager::actionDestroyed );
QString actionText = action->text();
actionText.remove( '&' ); // remove the accelerator
// load overridden value from settings
QgsSettings settings;
QString sequence = settings.value( mSettingsPath + actionText, defaultSequence ).toString();
action->setShortcut( sequence );
action->setToolTip( "<b>" + action->toolTip() + "</b>" );
updateActionToolTip( action, sequence );
return true;
}
void QgsLocator::registerFilter( QgsLocatorFilter *filter )
{
mFilters.append( filter );
filter->setParent( this );
if ( !filter->prefix().isEmpty() )
{
if ( filter->name() == QStringLiteral( "actions" ) || filter->name() == QStringLiteral( "processing_alg" )
|| filter->name() == QStringLiteral( "layertree" ) || filter->name() == QStringLiteral( "layouts" )
|| filter->name() == QStringLiteral( "features" ) )
{
//inbuilt filter, no prefix check
mPrefixedFilters.insert( filter->prefix(), filter );
}
else if ( filter->prefix().length() >= 3 )
{
mPrefixedFilters.insert( filter->prefix(), filter );
}
}
// restore settings
QgsSettings settings;
bool enabled = settings.value( QStringLiteral( "locator_filters/enabled_%1" ).arg( filter->name() ), true, QgsSettings::Section::Gui ).toBool();
bool byDefault = settings.value( QStringLiteral( "locator_filters/default_%1" ).arg( filter->name() ), filter->useWithoutPrefix(), QgsSettings::Section::Gui ).toBool();
filter->setEnabled( enabled );
filter->setUseWithoutPrefix( byDefault );
}
QgsAttributeTypeDialog::~QgsAttributeTypeDialog()
{
QgsSettings settings;
settings.setValue( QStringLiteral( "Windows/QgsAttributeTypeDialog/geometry" ), saveGeometry() );
qDeleteAll( mEditorConfigWidgets );
}
void QgsRasterCalcDialog::mButtonBox_accepted()
{
//save last output format
QgsSettings s;
s.setValue( QStringLiteral( "/RasterCalculator/lastOutputFormat" ), QVariant( mOutputFormatComboBox->currentText() ) );
s.setValue( QStringLiteral( "/RasterCalculator/lastOutputDir" ), QVariant( QFileInfo( mOutputLayer->filePath() ).absolutePath() ) );
}
bool QgsRasterRendererRegistry::minMaxValuesForBand( int band, QgsRasterDataProvider *provider, double &minValue, double &maxValue ) const
{
if ( !provider )
{
return false;
}
minValue = 0;
maxValue = 0;
QgsSettings s;
if ( s.value( QStringLiteral( "/Raster/useStandardDeviation" ), false ).toBool() )
{
QgsRasterBandStats stats = provider->bandStatistics( band, QgsRasterBandStats::Mean | QgsRasterBandStats::StdDev );
double stdDevFactor = s.value( QStringLiteral( "/Raster/defaultStandardDeviation" ), 2.0 ).toDouble();
double diff = stdDevFactor * stats.stdDev;
minValue = stats.mean - diff;
maxValue = stats.mean + diff;
}
else
{
QgsRasterBandStats stats = provider->bandStatistics( band, QgsRasterBandStats::Min | QgsRasterBandStats::Max );
minValue = stats.minimumValue;
maxValue = stats.maximumValue;
}
return true;
}
void QgsPropertyOverrideButton::showAssistant()
{
//first step - try to convert any existing expression to a transformer if one doesn't
//already exist
if ( !mProperty.transformer() )
{
( void )mProperty.convertToTransformer();
}
QgsPanelWidget *panel = QgsPanelWidget::findParentPanel( this );
QgsPropertyAssistantWidget *widget = new QgsPropertyAssistantWidget( panel, mDefinition, mProperty, mVectorLayer );
widget->registerExpressionContextGenerator( mExpressionContextGenerator );
widget->setSymbol( mSymbol ); // we only show legend preview in dialog version
if ( panel && panel->dockMode() )
{
connect( widget, &QgsPropertyAssistantWidget::widgetChanged, this, [this, widget]
{
widget->updateProperty( this->mProperty );
mExpressionString = this->mProperty.asExpression();
mFieldName = this->mProperty.field();
updateSiblingWidgets( isActive() );
this->emit changed();
} );
connect( widget, &QgsPropertyAssistantWidget::panelAccepted, this, [ = ] { updateGui(); } );
panel->openPanel( widget );
return;
}
else
{
// Show the dialog version if not in a panel
QDialog *dlg = new QDialog( this );
QString key = QStringLiteral( "/UI/paneldialog/%1" ).arg( widget->panelTitle() );
QgsSettings settings;
dlg->restoreGeometry( settings.value( key ).toByteArray() );
dlg->setWindowTitle( widget->panelTitle() );
dlg->setLayout( new QVBoxLayout() );
dlg->layout()->addWidget( widget );
QDialogButtonBox *buttonBox = new QDialogButtonBox( QDialogButtonBox::Cancel | QDialogButtonBox::Help | QDialogButtonBox::Ok );
connect( buttonBox, &QDialogButtonBox::accepted, dlg, &QDialog::accept );
connect( buttonBox, &QDialogButtonBox::rejected, dlg, &QDialog::reject );
connect( buttonBox, &QDialogButtonBox::helpRequested, this, &QgsPropertyOverrideButton::showHelp );
dlg->layout()->addWidget( buttonBox );
if ( dlg->exec() == QDialog::Accepted )
{
widget->updateProperty( mProperty );
mExpressionString = mProperty.asExpression();
mFieldName = mProperty.field();
widget->acceptPanel();
updateSiblingWidgets( isActive() );
updateGui();
emit changed();
}
settings.setValue( key, dlg->saveGeometry() );
}
}
QgsWFSSourceSelect::QgsWFSSourceSelect( QWidget *parent, Qt::WindowFlags fl, QgsProviderRegistry::WidgetMode theWidgetMode )
: QgsAbstractDataSourceWidget( parent, fl, theWidgetMode )
{
setupUi( this );
connect( cmbConnections, static_cast<void ( QComboBox::* )( int )>( &QComboBox::activated ), this, &QgsWFSSourceSelect::cmbConnections_activated );
connect( btnSave, &QPushButton::clicked, this, &QgsWFSSourceSelect::btnSave_clicked );
connect( btnLoad, &QPushButton::clicked, this, &QgsWFSSourceSelect::btnLoad_clicked );
setupButtons( buttonBox );
connect( buttonBox, &QDialogButtonBox::helpRequested, this, &QgsWFSSourceSelect::showHelp );
if ( widgetMode() != QgsProviderRegistry::WidgetMode::None )
{
mHoldDialogOpen->hide();
}
mBuildQueryButton = new QPushButton( tr( "&Build query" ) );
mBuildQueryButton->setToolTip( tr( "Build query" ) );
mBuildQueryButton->setDisabled( true );
buttonBox->addButton( mBuildQueryButton, QDialogButtonBox::ActionRole );
connect( mBuildQueryButton, &QAbstractButton::clicked, this, &QgsWFSSourceSelect::buildQueryButtonClicked );
connect( buttonBox, &QDialogButtonBox::rejected, this, &QDialog::reject );
connect( btnNew, &QAbstractButton::clicked, this, &QgsWFSSourceSelect::addEntryToServerList );
connect( btnEdit, &QAbstractButton::clicked, this, &QgsWFSSourceSelect::modifyEntryOfServerList );
connect( btnDelete, &QAbstractButton::clicked, this, &QgsWFSSourceSelect::deleteEntryOfServerList );
connect( btnConnect, &QAbstractButton::clicked, this, &QgsWFSSourceSelect::connectToServer );
connect( btnChangeSpatialRefSys, &QAbstractButton::clicked, this, &QgsWFSSourceSelect::changeCRS );
connect( lineFilter, &QLineEdit::textChanged, this, &QgsWFSSourceSelect::filterChanged );
populateConnectionList();
mProjectionSelector = new QgsProjectionSelectionDialog( this );
mProjectionSelector->setMessage( QString() );
mItemDelegate = new QgsWFSItemDelegate( treeView );
treeView->setItemDelegate( mItemDelegate );
QgsSettings settings;
QgsDebugMsg( QStringLiteral( "restoring settings" ) );
restoreGeometry( settings.value( QStringLiteral( "Windows/WFSSourceSelect/geometry" ) ).toByteArray() );
cbxUseTitleLayerName->setChecked( settings.value( QStringLiteral( "Windows/WFSSourceSelect/UseTitleLayerName" ), false ).toBool() );
cbxFeatureCurrentViewExtent->setChecked( settings.value( QStringLiteral( "Windows/WFSSourceSelect/FeatureCurrentViewExtent" ), true ).toBool() );
mHoldDialogOpen->setChecked( settings.value( QStringLiteral( "Windows/WFSSourceSelect/HoldDialogOpen" ), false ).toBool() );
mModel = new QStandardItemModel();
mModel->setHorizontalHeaderItem( MODEL_IDX_TITLE, new QStandardItem( QStringLiteral( "Title" ) ) );
mModel->setHorizontalHeaderItem( MODEL_IDX_NAME, new QStandardItem( QStringLiteral( "Name" ) ) );
mModel->setHorizontalHeaderItem( MODEL_IDX_ABSTRACT, new QStandardItem( QStringLiteral( "Abstract" ) ) );
mModel->setHorizontalHeaderItem( MODEL_IDX_SQL, new QStandardItem( QStringLiteral( "Sql" ) ) );
mModelProxy = new QSortFilterProxyModel( this );
mModelProxy->setSourceModel( mModel );
mModelProxy->setSortCaseSensitivity( Qt::CaseInsensitive );
treeView->setModel( mModelProxy );
connect( treeView, &QAbstractItemView::doubleClicked, this, &QgsWFSSourceSelect::treeWidgetItemDoubleClicked );
connect( treeView->selectionModel(), &QItemSelectionModel::currentRowChanged, this, &QgsWFSSourceSelect::treeWidgetCurrentRowChanged );
}
QgsVectorLayerRenderer::QgsVectorLayerRenderer( QgsVectorLayer *layer, QgsRenderContext &context )
: QgsMapLayerRenderer( layer->id() )
, mContext( context )
, mInterruptionChecker( qgis::make_unique< QgsVectorLayerRendererInterruptionChecker >( context ) )
, mLayer( layer )
, mFields( layer->fields() )
, mLabeling( false )
, mDiagrams( false )
{
mSource = new QgsVectorLayerFeatureSource( layer );
mRenderer = layer->renderer() ? layer->renderer()->clone() : nullptr;
mSelectedFeatureIds = layer->selectedFeatureIds();
mDrawVertexMarkers = nullptr != layer->editBuffer();
mGeometryType = layer->geometryType();
mFeatureBlendMode = layer->featureBlendMode();
mSimplifyMethod = layer->simplifyMethod();
mSimplifyGeometry = layer->simplifyDrawingCanbeApplied( mContext, QgsVectorSimplifyMethod::GeometrySimplification );
QgsSettings settings;
mVertexMarkerOnlyForSelection = settings.value( QStringLiteral( "qgis/digitizing/marker_only_for_selected" ), true ).toBool();
QString markerTypeString = settings.value( QStringLiteral( "qgis/digitizing/marker_style" ), "Cross" ).toString();
if ( markerTypeString == QLatin1String( "Cross" ) )
{
mVertexMarkerStyle = QgsSymbolLayerUtils::Cross;
}
else if ( markerTypeString == QLatin1String( "SemiTransparentCircle" ) )
{
mVertexMarkerStyle = QgsSymbolLayerUtils::SemiTransparentCircle;
}
else
{
mVertexMarkerStyle = QgsSymbolLayerUtils::NoMarker;
}
mVertexMarkerSize = settings.value( QStringLiteral( "qgis/digitizing/marker_size_mm" ), 2.0 ).toDouble();
if ( !mRenderer )
return;
QgsDebugMsgLevel( "rendering v2:\n " + mRenderer->dump(), 2 );
if ( mDrawVertexMarkers )
{
// set editing vertex markers style
mRenderer->setVertexMarkerAppearance( mVertexMarkerStyle, mVertexMarkerSize );
}
mContext.expressionContext() << QgsExpressionContextUtils::layerScope( layer );
mAttrNames = mRenderer->usedAttributes( context );
//register label and diagram layer to the labeling engine
prepareLabeling( layer, mAttrNames );
prepareDiagrams( layer, mAttrNames );
}
void QgsBrowserDockWidget::showContextMenu( QPoint pt )
{
QModelIndex index = mProxyModel->mapToSource( mBrowserView->indexAt( pt ) );
QgsDataItem *item = mModel->dataItem( index );
if ( !item )
return;
QMenu *menu = new QMenu( this );
if ( item->type() == QgsDataItem::Directory )
{
QgsSettings settings;
QStringList favDirs = settings.value( QStringLiteral( "browser/favourites" ) ).toStringList();
bool inFavDirs = item->parent() && item->parent()->type() == QgsDataItem::Favorites;
if ( item->parent() && !inFavDirs )
{
// only non-root directories can be added as favorites
menu->addAction( tr( "Add as a Favorite" ), this, SLOT( addFavorite() ) );
}
else if ( inFavDirs )
{
// only favorites can be removed
menu->addAction( tr( "Remove Favorite" ), this, SLOT( removeFavorite() ) );
}
menu->addAction( tr( "Properties..." ), this, SLOT( showProperties() ) );
menu->addAction( tr( "Hide from Browser" ), this, SLOT( hideItem() ) );
QAction *action = menu->addAction( tr( "Fast Scan this Directory" ), this, SLOT( toggleFastScan() ) );
action->setCheckable( true );
action->setChecked( settings.value( QStringLiteral( "qgis/scanItemsFastScanUris" ),
QStringList() ).toStringList().contains( item->path() ) );
}
else if ( item->type() == QgsDataItem::Layer )
{
menu->addAction( tr( "Add Selected Layer(s)" ), this, SLOT( addSelectedLayers() ) );
menu->addAction( tr( "Properties..." ), this, SLOT( showProperties() ) );
}
else if ( item->type() == QgsDataItem::Favorites )
{
menu->addAction( tr( "Add a Directory..." ), this, SLOT( addFavoriteDirectory() ) );
}
QList<QAction *> actions = item->actions();
if ( !actions.isEmpty() )
{
if ( !menu->actions().isEmpty() )
menu->addSeparator();
// add action to the menu
menu->addActions( actions );
}
if ( menu->actions().isEmpty() )
{
delete menu;
return;
}
menu->popup( mBrowserView->mapToGlobal( pt ) );
}
QgsArcGisServiceSourceSelect::QgsArcGisServiceSourceSelect( const QString &serviceName, ServiceType serviceType, QWidget *parent, Qt::WindowFlags fl, QgsProviderRegistry::WidgetMode widgetMode )
: QgsAbstractDataSourceWidget( parent, fl, widgetMode )
, mServiceName( serviceName )
, mServiceType( serviceType )
{
setupUi( this );
connect( cmbConnections, static_cast<void ( QComboBox::* )( int )>( &QComboBox::activated ), this, &QgsArcGisServiceSourceSelect::cmbConnections_activated );
setupButtons( buttonBox );
connect( buttonBox, &QDialogButtonBox::helpRequested, this, &QgsArcGisServiceSourceSelect::showHelp );
setWindowTitle( QStringLiteral( "Add %1 Layer from a Server" ).arg( mServiceName ) );
if ( mServiceType == FeatureService )
{
mBuildQueryButton = buttonBox->addButton( tr( "&Build query" ), QDialogButtonBox::ActionRole );
mBuildQueryButton->setDisabled( true );
connect( mBuildQueryButton, &QAbstractButton::clicked, this, &QgsArcGisServiceSourceSelect::buildQueryButtonClicked );
}
connect( buttonBox, &QDialogButtonBox::rejected, this, &QDialog::reject );
connect( btnNew, &QAbstractButton::clicked, this, &QgsArcGisServiceSourceSelect::addEntryToServerList );
connect( btnEdit, &QAbstractButton::clicked, this, &QgsArcGisServiceSourceSelect::modifyEntryOfServerList );
connect( btnDelete, &QAbstractButton::clicked, this, &QgsArcGisServiceSourceSelect::deleteEntryOfServerList );
connect( btnConnect, &QAbstractButton::clicked, this, &QgsArcGisServiceSourceSelect::connectToServer );
connect( btnChangeSpatialRefSys, &QAbstractButton::clicked, this, &QgsArcGisServiceSourceSelect::changeCrs );
connect( lineFilter, &QLineEdit::textChanged, this, &QgsArcGisServiceSourceSelect::filterChanged );
populateConnectionList();
mProjectionSelector = new QgsProjectionSelectionDialog( this );
mProjectionSelector->setMessage( QString() );
treeView->setItemDelegate( new QgsAbstractDataSourceWidgetItemDelegate( treeView ) );
QgsSettings settings;
restoreGeometry( settings.value( QStringLiteral( "Windows/SourceSelectDialog/geometry" ) ).toByteArray() );
cbxUseTitleLayerName->setChecked( settings.value( QStringLiteral( "Windows/SourceSelectDialog/UseTitleLayerName" ), false ).toBool() );
mModel = new QStandardItemModel();
mModel->setHorizontalHeaderItem( 0, new QStandardItem( QStringLiteral( "Title" ) ) );
mModel->setHorizontalHeaderItem( 1, new QStandardItem( QStringLiteral( "Name" ) ) );
mModel->setHorizontalHeaderItem( 2, new QStandardItem( QStringLiteral( "Abstract" ) ) );
if ( serviceType == FeatureService )
{
mModel->setHorizontalHeaderItem( 3, new QStandardItem( QStringLiteral( "Cache Feature" ) ) );
mModel->setHorizontalHeaderItem( 4, new QStandardItem( QStringLiteral( "Filter" ) ) );
gbImageEncoding->hide();
}
else
{
cbxFeatureCurrentViewExtent->hide();
mImageEncodingGroup = new QButtonGroup( this );
}
mModelProxy = new QSortFilterProxyModel( this );
mModelProxy->setSourceModel( mModel );
mModelProxy->setSortCaseSensitivity( Qt::CaseInsensitive );
treeView->setModel( mModelProxy );
connect( treeView, &QAbstractItemView::doubleClicked, this, &QgsArcGisServiceSourceSelect::treeWidgetItemDoubleClicked );
connect( treeView->selectionModel(), &QItemSelectionModel::currentRowChanged, this, &QgsArcGisServiceSourceSelect::treeWidgetCurrentRowChanged );
}
QgsDwgImportDialog::~QgsDwgImportDialog()
{
QgsSettings s;
s.setValue( QStringLiteral( "/DwgImport/lastExpandInserts" ), cbExpandInserts->isChecked() );
s.setValue( QStringLiteral( "/DwgImport/lastMergeLayers" ), cbMergeLayers->isChecked() );
s.setValue( QStringLiteral( "/DwgImport/lastUseCurves" ), cbUseCurves->isChecked() );
s.setValue( QStringLiteral( "/Windows/DwgImport/geometry" ), saveGeometry() );
}
QgsGeoPackageConnection::QgsGeoPackageConnection( const QString &connName )
: mConnName( connName )
{
QgsSettings settings;
QString key = QStringLiteral( "%1/%2/path" ).arg( connectionsPath( ), mConnName );
mPath = settings.value( key ).toString();
}
QgsBrowserPropertiesDialog::QgsBrowserPropertiesDialog( const QString &settingsSection, QWidget *parent )
: QDialog( parent )
, mSettingsSection( settingsSection )
{
setupUi( this );
QgsSettings settings;
restoreGeometry( settings.value( mSettingsSection + "/propertiesDialog/geometry" ).toByteArray() );
}
void QgsTileScaleWidget::showTileScale( QMainWindow *mainWindow )
{
QgsDockWidget *dock = mainWindow->findChild<QgsDockWidget *>( QStringLiteral( "theTileScaleDock" ) );
if ( dock )
{
dock->setVisible( dock->isHidden() );
return;
}
QgsMapCanvas *canvas = mainWindow->findChild<QgsMapCanvas *>( QStringLiteral( "theMapCanvas" ) );
QgsDebugMsg( QString( "canvas:%1 [%2]" ).arg( ( quint64 ) canvas, 0, 16 ).arg( canvas ? canvas->objectName() : "" ) );
if ( !canvas )
{
QgsDebugMsg( "map canvas mapCanvas not found" );
return;
}
QgsTileScaleWidget *tws = new QgsTileScaleWidget( canvas );
tws->setObjectName( QStringLiteral( "theTileScaleWidget" ) );
QgsLayerTreeView *legend = mainWindow->findChild<QgsLayerTreeView *>( QStringLiteral( "theLayerTreeView" ) );
if ( legend )
{
connect( legend, &QgsLayerTreeView::currentLayerChanged,
tws, &QgsTileScaleWidget::layerChanged );
}
else
{
QgsDebugMsg( "legend not found" );
}
//create the dock widget
dock = new QgsDockWidget( tr( "Tile Scale" ), mainWindow );
dock->setObjectName( QStringLiteral( "theTileScaleDock" ) );
connect( dock, &QDockWidget::dockLocationChanged, tws, &QgsTileScaleWidget::locationChanged );
mainWindow->addDockWidget( Qt::RightDockWidgetArea, dock );
// add to the Panel submenu
QMenu *panelMenu = mainWindow->findChild<QMenu *>( QStringLiteral( "mPanelMenu" ) );
if ( panelMenu )
{
// add to the Panel submenu
panelMenu->addAction( dock->toggleViewAction() );
}
else
{
QgsDebugMsg( "panel menu not found" );
}
dock->setWidget( tws );
connect( dock, &QDockWidget::visibilityChanged, tws, &QgsTileScaleWidget::scaleEnabled );
QgsSettings settings;
dock->setVisible( settings.value( QStringLiteral( "UI/tileScaleEnabled" ), false ).toBool() );
}
double QgsTolerance::vertexSearchRadius( const QgsMapSettings &mapSettings )
{
QgsSettings settings;
double tolerance = settings.value( QStringLiteral( "qgis/digitizing/search_radius_vertex_edit" ), 10 ).toDouble();
UnitType units = static_cast< QgsTolerance::UnitType >( settings.value( QStringLiteral( "qgis/digitizing/search_radius_vertex_edit_unit" ), QgsTolerance::Pixels ).toInt() );
if ( units == LayerUnits )
units = ProjectUnits;
return toleranceInProjectUnits( tolerance, nullptr, mapSettings, units );
}
QgsCptCityArchive *QgsCptCityArchive::defaultArchive()
{
QgsSettings settings;
sDefaultArchiveName = settings.value( QStringLiteral( "CptCity/archiveName" ), DEFAULT_CPTCITY_ARCHIVE ).toString();
if ( QgsCptCityArchive::sArchiveRegistry.contains( sDefaultArchiveName ) )
return QgsCptCityArchive::sArchiveRegistry.value( sDefaultArchiveName );
else
return nullptr;
}
QgsMergeAttributesDialog::QgsMergeAttributesDialog()
{
setupUi( this );
connect( mFromSelectedPushButton, &QPushButton::clicked, this, &QgsMergeAttributesDialog::mFromSelectedPushButton_clicked );
connect( mRemoveFeatureFromSelectionButton, &QPushButton::clicked, this, &QgsMergeAttributesDialog::mRemoveFeatureFromSelectionButton_clicked );
QgsSettings settings;
restoreGeometry( settings.value( QStringLiteral( "Windows/MergeAttributes/geometry" ) ).toByteArray() );
}
QgsComposerLabel::QgsComposerLabel( QgsComposition *composition )
: QgsComposerItem( composition )
, mHtmlState( 0 )
, mHtmlUnitsToMM( 1.0 )
, mHtmlLoaded( false )
, mMarginX( 1.0 )
, mMarginY( 1.0 )
, mFontColor( QColor( 0, 0, 0 ) )
, mHAlignment( Qt::AlignLeft )
, mVAlignment( Qt::AlignTop )
, mDistanceArea( nullptr )
{
mDistanceArea = new QgsDistanceArea();
mHtmlUnitsToMM = htmlUnitsToMM();
//get default composer font from settings
QgsSettings settings;
QString defaultFontString = settings.value( QStringLiteral( "Composer/defaultFont" ) ).toString();
if ( !defaultFontString.isEmpty() )
{
mFont.setFamily( defaultFontString );
}
//default to a 10 point font size
mFont.setPointSizeF( 10 );
//default to no background
setBackgroundEnabled( false );
//a label added while atlas preview is enabled needs to have the expression context set,
//otherwise fields in the label aren't correctly evaluated until atlas preview feature changes (#9457)
refreshExpressionContext();
if ( mComposition )
{
//connect to atlas feature changes
//to update the expression context
connect( &mComposition->atlasComposition(), &QgsAtlasComposition::featureChanged, this, &QgsComposerLabel::refreshExpressionContext );
connect( mComposition, &QgsComposition::refreshItemsTriggered, this, &QgsComposerLabel::contentChanged );
}
mWebPage = new QgsWebPage( this );
mWebPage->setIdentifier( tr( "Composer label item" ) );
mWebPage->setNetworkAccessManager( QgsNetworkAccessManager::instance() );
//This makes the background transparent. Found on http://blog.qt.digia.com/blog/2009/06/30/transparent-qwebview-or-qwebpage/
QPalette palette = mWebPage->palette();
palette.setBrush( QPalette::Base, Qt::transparent );
mWebPage->setPalette( palette );
//webPage->setAttribute(Qt::WA_OpaquePaintEvent, false); //this does not compile, why ?
mWebPage->mainFrame()->setZoomFactor( 10.0 );
mWebPage->mainFrame()->setScrollBarPolicy( Qt::Horizontal, Qt::ScrollBarAlwaysOff );
mWebPage->mainFrame()->setScrollBarPolicy( Qt::Vertical, Qt::ScrollBarAlwaysOff );
connect( mWebPage, &QWebPage::loadFinished, this, &QgsComposerLabel::loadingHtmlFinished );
}
void QgsMapToolLabel::createRubberBands()
{
delete mLabelRubberBand;
delete mFeatureRubberBand;
//label rubber band
QgsRectangle rect = mCurrentLabel.pos.labelRect;
mLabelRubberBand = new QgsRubberBand( mCanvas, QgsWkbTypes::LineGeometry );
mLabelRubberBand->addPoint( QgsPointXY( rect.xMinimum(), rect.yMinimum() ) );
mLabelRubberBand->addPoint( QgsPointXY( rect.xMinimum(), rect.yMaximum() ) );
mLabelRubberBand->addPoint( QgsPointXY( rect.xMaximum(), rect.yMaximum() ) );
mLabelRubberBand->addPoint( QgsPointXY( rect.xMaximum(), rect.yMinimum() ) );
mLabelRubberBand->addPoint( QgsPointXY( rect.xMinimum(), rect.yMinimum() ) );
mLabelRubberBand->setColor( QColor( 0, 255, 0, 65 ) );
mLabelRubberBand->setWidth( 3 );
mLabelRubberBand->show();
//feature rubber band
QgsVectorLayer *vlayer = mCurrentLabel.layer;
if ( vlayer )
{
QgsFeature f;
if ( currentFeature( f, true ) )
{
QgsGeometry geom = f.geometry();
if ( !geom.isNull() )
{
QgsSettings settings;
int r = settings.value( QStringLiteral( "qgis/digitizing/line_color_red" ), 255 ).toInt();
int g = settings.value( QStringLiteral( "qgis/digitizing/line_color_green" ), 0 ).toInt();
int b = settings.value( QStringLiteral( "qgis/digitizing/line_color_blue" ), 0 ).toInt();
int a = settings.value( QStringLiteral( "qgis/digitizing/line_color_alpha" ), 200 ).toInt();
mFeatureRubberBand = new QgsRubberBand( mCanvas, geom.type() );
mFeatureRubberBand->setColor( QColor( r, g, b, a ) );
mFeatureRubberBand->setToGeometry( geom, vlayer );
mFeatureRubberBand->show();
}
}
//fixpoint rubber band
QgsPointXY fixPoint;
if ( currentLabelRotationPoint( fixPoint, false, false ) )
{
if ( mCanvas )
{
const QgsMapSettings &s = mCanvas->mapSettings();
fixPoint = s.mapToLayerCoordinates( vlayer, fixPoint );
}
QgsGeometry pointGeom = QgsGeometry::fromPointXY( fixPoint );
mFixPointRubberBand = new QgsRubberBand( mCanvas, QgsWkbTypes::LineGeometry );
mFixPointRubberBand->setColor( QColor( 0, 0, 255, 65 ) );
mFixPointRubberBand->setToGeometry( pointGeom, vlayer );
mFixPointRubberBand->show();
}
}
}
QgsSpatiaLiteConnection::QgsSpatiaLiteConnection( const QString &name )
{
// "name" can be either a saved connection or a path to database
QgsSettings settings;
mPath = settings.value( QStringLiteral( "SpatiaLite/connections/%1/sqlitepath" ).arg( name ) ).toString();
if ( mPath.isNull() )
mPath = name; // not found in settings - probably it's a path
}
QgsAttributeTypeDialog::QgsAttributeTypeDialog( QgsVectorLayer *vl, int fieldIdx )
: QDialog()
, mLayer( vl )
, mFieldIdx( fieldIdx )
{
setupUi( this );
setWindowTitle( tr( "Edit Widget Properties - %1 (%2)" ).arg( vl->fields().at( fieldIdx ).name(), vl->name() ) );
QMapIterator<QString, QgsEditorWidgetFactory *> it( QgsGui::editorWidgetRegistry()->factories() );
while ( it.hasNext() )
{
it.next();
QListWidgetItem *item = new QListWidgetItem( selectionListWidget );
item->setText( it.value()->name() );
item->setData( Qt::UserRole, it.key() );
if ( !it.value()->supportsField( vl, fieldIdx ) )
item->setFlags( item->flags() & ~Qt::ItemIsEnabled );
selectionListWidget->addItem( item );
}
// Set required list width based on content + twice the border width
selectionListWidget->setMinimumWidth( selectionListWidget->sizeHintForColumn( 0 )
+ 2 );
selectionListWidget->setMaximumWidth( selectionListWidget->sizeHintForColumn( 0 )
+ 2 );
if ( vl->fields().fieldOrigin( fieldIdx ) == QgsFields::OriginJoin ||
vl->fields().fieldOrigin( fieldIdx ) == QgsFields::OriginExpression )
{
isFieldEditableCheckBox->setEnabled( false );
}
mExpressionWidget->registerExpressionContextGenerator( this );
connect( mExpressionWidget, &QgsExpressionLineEdit::expressionChanged, this, &QgsAttributeTypeDialog::defaultExpressionChanged );
connect( mUniqueCheckBox, &QCheckBox::toggled, this, [ = ]( bool checked )
{
mCheckBoxEnforceUnique->setEnabled( checked );
if ( !checked )
mCheckBoxEnforceUnique->setChecked( false );
}
);
connect( notNullCheckBox, &QCheckBox::toggled, this, [ = ]( bool checked )
{
mCheckBoxEnforceNotNull->setEnabled( checked );
if ( !checked )
mCheckBoxEnforceNotNull->setChecked( false );
}
);
QgsSettings settings;
restoreGeometry( settings.value( QStringLiteral( "Windows/QgsAttributeTypeDialog/geometry" ) ).toByteArray() );
constraintExpressionWidget->setLayer( vl );
connect( buttonBox, &QDialogButtonBox::helpRequested, this, &QgsAttributeTypeDialog::showHelp );
}
void QgsProjectLayerGroupDialog::mButtonBox_accepted()
{
QgsSettings s;
QFileInfo fi( mProjectPath );
if ( fi.exists() )
{
s.setValue( QStringLiteral( "/qgis/last_embedded_project_path" ), fi.absolutePath() );
}
accept();
}
void QgsMapToolSimplify::setTolerance( double tolerance )
{
mTolerance = tolerance;
QgsSettings settings;
settings.setValue( QStringLiteral( "digitizing/simplify_tolerance" ), tolerance );
if ( !mSelectedFeatures.isEmpty() )
updateSimplificationPreview();
}
void QgsMapToolSimplify::setToleranceUnits( QgsTolerance::UnitType units )
{
mToleranceUnits = units;
QgsSettings settings;
settings.setValue( QStringLiteral( "digitizing/simplify_tolerance_units" ), units );
if ( !mSelectedFeatures.isEmpty() )
updateSimplificationPreview();
}
QgsArcGisServiceSourceSelect::~QgsArcGisServiceSourceSelect()
{
QgsSettings settings;
settings.setValue( QStringLiteral( "Windows/SourceSelectDialog/geometry" ), saveGeometry() );
settings.setValue( QStringLiteral( "Windows/SourceSelectDialog/UseTitleLayerName" ), cbxUseTitleLayerName->isChecked() );
delete mProjectionSelector;
delete mModel;
delete mModelProxy;
}
QgsAttributeSelectionDialog::QgsAttributeSelectionDialog( QgsComposerAttributeTableV2 *table, QgsVectorLayer *vLayer,
QWidget *parent, Qt::WindowFlags f )
: QDialog( parent, f )
, mComposerTable( table )
, mVectorLayer( vLayer )
{
setupUi( this );
connect( mRemoveColumnPushButton, &QPushButton::clicked, this, &QgsAttributeSelectionDialog::mRemoveColumnPushButton_clicked );
connect( mAddColumnPushButton, &QPushButton::clicked, this, &QgsAttributeSelectionDialog::mAddColumnPushButton_clicked );
connect( mColumnUpPushButton, &QPushButton::clicked, this, &QgsAttributeSelectionDialog::mColumnUpPushButton_clicked );
connect( mColumnDownPushButton, &QPushButton::clicked, this, &QgsAttributeSelectionDialog::mColumnDownPushButton_clicked );
connect( mResetColumnsPushButton, &QPushButton::clicked, this, &QgsAttributeSelectionDialog::mResetColumnsPushButton_clicked );
connect( mClearColumnsPushButton, &QPushButton::clicked, this, &QgsAttributeSelectionDialog::mClearColumnsPushButton_clicked );
connect( mAddSortColumnPushButton, &QPushButton::clicked, this, &QgsAttributeSelectionDialog::mAddSortColumnPushButton_clicked );
connect( mRemoveSortColumnPushButton, &QPushButton::clicked, this, &QgsAttributeSelectionDialog::mRemoveSortColumnPushButton_clicked );
connect( mSortColumnUpPushButton, &QPushButton::clicked, this, &QgsAttributeSelectionDialog::mSortColumnUpPushButton_clicked );
connect( mSortColumnDownPushButton, &QPushButton::clicked, this, &QgsAttributeSelectionDialog::mSortColumnDownPushButton_clicked );
QgsSettings settings;
restoreGeometry( settings.value( QStringLiteral( "Windows/AttributeSelectionDialog/geometry" ) ).toByteArray() );
if ( mComposerTable )
{
//set up models, views and delegates
mColumnModel = new QgsComposerAttributeTableColumnModelV2( mComposerTable, mColumnsTableView );
mColumnsTableView->setModel( mColumnModel );
mColumnsTableView->horizontalHeader()->setSectionResizeMode( QHeaderView::Stretch );
mColumnSourceDelegate = new QgsComposerColumnSourceDelegate( vLayer, mColumnsTableView, mComposerTable );
mColumnsTableView->setItemDelegateForColumn( 0, mColumnSourceDelegate );
mColumnAlignmentDelegate = new QgsComposerColumnAlignmentDelegate( mColumnsTableView );
mColumnsTableView->setItemDelegateForColumn( 2, mColumnAlignmentDelegate );
mColumnWidthDelegate = new QgsComposerColumnWidthDelegate( mColumnsTableView );
mColumnsTableView->setItemDelegateForColumn( 3, mColumnWidthDelegate );
mAvailableSortProxyModel = new QgsComposerTableSortColumnsProxyModelV2( mComposerTable, QgsComposerTableSortColumnsProxyModelV2::ShowUnsortedColumns, mSortColumnComboBox );
mAvailableSortProxyModel->setSourceModel( mColumnModel );
mSortColumnComboBox->setModel( mAvailableSortProxyModel );
mSortColumnComboBox->setModelColumn( 0 );
mColumnSortOrderDelegate = new QgsComposerColumnSortOrderDelegate( mSortColumnTableView );
mSortColumnTableView->setItemDelegateForColumn( 1, mColumnSortOrderDelegate );
mSortedProxyModel = new QgsComposerTableSortColumnsProxyModelV2( mComposerTable, QgsComposerTableSortColumnsProxyModelV2::ShowSortedColumns, mSortColumnTableView );
mSortedProxyModel->setSourceModel( mColumnModel );
mSortedProxyModel->sort( 0, Qt::AscendingOrder );
mSortColumnTableView->setSortingEnabled( false );
mSortColumnTableView->setModel( mSortedProxyModel );
mSortColumnTableView->horizontalHeader()->setSectionResizeMode( QHeaderView::Stretch );
}
mOrderComboBox->insertItem( 0, tr( "Ascending" ) );
mOrderComboBox->insertItem( 1, tr( "Descending" ) );
}
void QgsGrassNewMapset::databaseChanged()
{
QgsSettings settings;
settings.setValue( QStringLiteral( "GRASS/lastGisdbase" ), mDatabaseLineEdit->text() );
button( QWizard::NextButton )->setEnabled( false );
setError( mDatabaseErrorLabel );
if ( gisdbase().isEmpty() )
{
//setError( mDatabaseErrorLabel, tr( "Enter path to GRASS database" ) );
button( QWizard::NextButton )->setEnabled( false );
return;
}
button( QWizard::NextButton )->setEnabled( true );
if ( !gisdbaseExists() )
{
// Do not warn, it may be default $HOME/grassdata, if does not exist, it will be created on finish
//setError( mDatabaseErrorLabel, tr( "The directory doesn't exist!" ) );
//return;
}
else
{
// Check if at least one writable location exists or database is writable
bool locationExists = false;
QDir dir( gisdbase() );
for ( unsigned int i = 0; i < dir.count(); i++ )
{
if ( dir[i] == QLatin1String( "." ) || dir[i] == QLatin1String( ".." ) )
continue;
QString windName = gisdbase() + "/" + dir[i] + "/PERMANENT/DEFAULT_WIND";
QString locationName = gisdbase() + "/" + dir[i];
QFileInfo locationInfo( locationName );
if ( QFile::exists( windName ) && locationInfo.isWritable() )
{
locationExists = true;
break;
}
}
QFileInfo gisdbaseInfo( gisdbase() );
if ( locationExists || gisdbaseInfo.isWritable() )
{
button( QWizard::NextButton )->setEnabled( true );
}
else
{
setError( mDatabaseErrorLabel, tr( "No writable locations, the database is not writable!" ) );
}
}
}
