double QgsTolerance::defaultTolerance( QgsMapLayer *layer, const QgsMapSettings &mapSettings )
{
QgsSettings settings;
double tolerance = settings.value( QStringLiteral( "qgis/digitizing/default_snapping_tolerance" ), 0 ).toDouble();
UnitType units = static_cast< QgsTolerance::UnitType >( settings.value( QStringLiteral( "qgis/digitizing/default_snapping_tolerance_unit" ), ProjectUnits ).toInt() );
return toleranceInMapUnits( tolerance, layer, mapSettings, units );
}
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;
}
double QgsTolerance::vertexSearchRadius( QgsMapLayer *layer, 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() );
return toleranceInMapUnits( tolerance, layer, mapSettings, units );
}
QgsGeoNodeConnection::QgsGeoNodeConnection( const QString &name )
: mConnName( name )
{
QgsSettings settings;
// settings.Section
QString key = settingsKey();
QString credentialsKey = QgsGeoNodeConnectionUtils::pathGeoNodeConnectionDetails() + QStringLiteral( "/" ) + mConnName;
mUri.setParam( QStringLiteral( "url" ), settings.value( key + QStringLiteral( "/url" ), QString() ).toString() );
// Check for credentials and prepend to the connection info
QString username = settings.value( credentialsKey + QStringLiteral( "/username" ), QString() ).toString();
QString password = settings.value( credentialsKey + QStringLiteral( "/password" ), QString() ).toString();
if ( !username.isEmpty() )
{
mUri.setParam( QStringLiteral( "username" ), username );
mUri.setParam( QStringLiteral( "password" ), password );
}
QString authcfg = settings.value( credentialsKey + QStringLiteral( "/authcfg" ), QString() ).toString();
if ( !authcfg.isEmpty() )
{
mUri.setParam( QStringLiteral( "authcfg" ), authcfg );
}
QgsDebugMsgLevel( QStringLiteral( "encodedUri: '%1'." ).arg( QString( mUri.encodedUri() ) ), 4 );
}
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" ) || filter->name() == QStringLiteral( "calculator" )
|| filter->name() == QStringLiteral( "bookmarks" ) )
{
//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 );
}
QgsLayoutItemPropertiesDialog::QgsLayoutItemPropertiesDialog( QWidget *parent, Qt::WindowFlags flags )
: QDialog( parent, flags )
{
setupUi( this );
QgsGui::instance()->enableAutoGeometryRestore( this );
//make button exclusive
QButtonGroup *buttonGroup = new QButtonGroup( this );
buttonGroup->addButton( mUpperLeftRadioButton );
buttonGroup->addButton( mUpperMiddleRadioButton );
buttonGroup->addButton( mUpperRightRadioButton );
buttonGroup->addButton( mMiddleLeftRadioButton );
buttonGroup->addButton( mMiddleRadioButton );
buttonGroup->addButton( mMiddleRightRadioButton );
buttonGroup->addButton( mLowerLeftRadioButton );
buttonGroup->addButton( mLowerMiddleRadioButton );
buttonGroup->addButton( mLowerRightRadioButton );
buttonGroup->setExclusive( true );
QgsSettings settings;
double lastWidth = settings.value( QStringLiteral( "LayoutDesigner/lastItemWidth" ), QStringLiteral( "50" ) ).toDouble();
double lastHeight = settings.value( QStringLiteral( "LayoutDesigner/lastItemHeight" ), QStringLiteral( "50" ) ).toDouble();
QgsUnitTypes::LayoutUnit lastSizeUnit = settings.enumValue( QStringLiteral( "LayoutDesigner/lastSizeUnit" ), QgsUnitTypes::LayoutMillimeters );
setItemSize( QgsLayoutSize( lastWidth, lastHeight, lastSizeUnit ) );
mPosUnitsComboBox->linkToWidget( mXPosSpin );
mPosUnitsComboBox->linkToWidget( mYPosSpin );
mSizeUnitsComboBox->linkToWidget( mWidthSpin );
mSizeUnitsComboBox->linkToWidget( mHeightSpin );
mLockAspectRatio->setWidthSpinBox( mWidthSpin );
mLockAspectRatio->setHeightSpinBox( mHeightSpin );
}
void QgsDisplayAngle::updateUi()
{
QgsSettings settings;
QgsUnitTypes::AngleUnit unit = QgsUnitTypes::decodeAngleUnit( settings.value( QStringLiteral( "qgis/measure/angleunits" ), QgsUnitTypes::encodeUnit( QgsUnitTypes::AngleDegrees ) ).toString() );
int decimals = settings.value( QStringLiteral( "qgis/measure/decimalplaces" ), "3" ).toInt();
mAngleLineEdit->setText( QgsUnitTypes::formatAngle( mValue * QgsUnitTypes::fromUnitToUnitFactor( QgsUnitTypes::AngleRadians, unit ), decimals, unit ) );
}
QgsDataSourceUri &QgsOwsConnection::addWmsWcsConnectionSettings( QgsDataSourceUri &uri, const QString &settingsKey )
{
addCommonConnectionSettings( uri, settingsKey );
QgsSettings settings;
QString referer = settings.value( settingsKey + "/referer" ).toString();
if ( !referer.isEmpty() )
{
uri.setParam( QStringLiteral( "referer" ), referer );
}
if ( settings.value( settingsKey + QStringLiteral( "/ignoreGetMapURI" ), false ).toBool() )
{
uri.setParam( QStringLiteral( "IgnoreGetMapUrl" ), QStringLiteral( "1" ) );
}
if ( settings.value( settingsKey + QStringLiteral( "/ignoreGetFeatureInfoURI" ), false ).toBool() )
{
uri.setParam( QStringLiteral( "IgnoreGetFeatureInfoUrl" ), QStringLiteral( "1" ) );
}
if ( settings.value( settingsKey + QStringLiteral( "/smoothPixmapTransform" ), false ).toBool() )
{
uri.setParam( QStringLiteral( "SmoothPixmapTransform" ), QStringLiteral( "1" ) );
}
QString dpiMode = settings.value( settingsKey + QStringLiteral( "/dpiMode" ), QStringLiteral( "all" ) ).toString();
if ( !dpiMode.isEmpty() )
{
uri.setParam( QStringLiteral( "dpiMode" ), dpiMode );
}
return uri;
}
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 ) );
}
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 );
}
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 );
}
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 QgsMessageLogViewer::logMessage( const QString &message, const QString &tag, Qgis::MessageLevel level )
{
QString cleanedTag = tag;
if ( cleanedTag.isNull() )
cleanedTag = tr( "General" );
int i;
for ( i = 0; i < tabWidget->count() && tabWidget->tabText( i ).remove( QChar( '&' ) ) != cleanedTag; i++ );
QPlainTextEdit *w = nullptr;
if ( i < tabWidget->count() )
{
w = qobject_cast<QPlainTextEdit *>( tabWidget->widget( i ) );
tabWidget->setCurrentIndex( i );
}
else
{
w = new QPlainTextEdit( this );
w->setReadOnly( true );
tabWidget->addTab( w, cleanedTag );
tabWidget->setCurrentIndex( tabWidget->count() - 1 );
}
QString levelString;
QgsSettings settings;
QColor color;
switch ( level )
{
case Qgis::Info:
levelString = QStringLiteral( "INFO" );
color = QColor( settings.value( QStringLiteral( "colors/info" ), QStringLiteral( "#000000" ) ).toString() );
break;
case Qgis::Warning:
levelString = QStringLiteral( "WARNING" );
color = QColor( settings.value( QStringLiteral( "colors/warning" ), QStringLiteral( "#000000" ) ).toString() );
break;
case Qgis::Critical:
levelString = QStringLiteral( "CRITICAL" );
color = QColor( settings.value( QStringLiteral( "colors/critical" ), QStringLiteral( "#000000" ) ).toString() );
break;
case Qgis::Success:
levelString = QStringLiteral( "SUCCESS" );
color = QColor( settings.value( QStringLiteral( "colors/success" ), QStringLiteral( "#000000" ) ).toString() );
break;
case Qgis::None:
levelString = QStringLiteral( "NONE" );
color = QColor( settings.value( QStringLiteral( "colors/default" ), QStringLiteral( "#000000" ) ).toString() );
break;
}
QString prefix = QStringLiteral( "<font color=\"%1\">%2 %3 </font>" )
.arg( color.name(), QDateTime::currentDateTime().toString( Qt::ISODate ), levelString );
QString cleanedMessage = message;
cleanedMessage = cleanedMessage.prepend( prefix ).replace( '\n', QLatin1String( "<br> " ) );
w->appendHtml( cleanedMessage );
w->verticalScrollBar()->setValue( w->verticalScrollBar()->maximum() );
}
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();
}
}
}
QgsMapToolSimplify::QgsMapToolSimplify( QgsMapCanvas *canvas )
: QgsMapToolEdit( canvas )
{
QgsSettings settings;
mTolerance = settings.value( QStringLiteral( "digitizing/simplify_tolerance" ), 1 ).toDouble();
mToleranceUnits = static_cast< QgsTolerance::UnitType >( settings.value( QStringLiteral( "digitizing/simplify_tolerance_units" ), 0 ).toInt() );
mMethod = static_cast< QgsMapToolSimplify::Method >( settings.value( QStringLiteral( "digitizing/simplify_method" ), 0 ).toInt() );
mSmoothIterations = settings.value( QStringLiteral( "digitizing/smooth_iterations" ), 1 ).toInt();
mSmoothOffset = settings.value( QStringLiteral( "digitizing/smooth_offset" ), 0.25 ).toDouble();
}
QMap<QString, QVariant> QgisAppStyleSheet::defaultOptions()
{
QMap<QString, QVariant> opts;
// the following default values, before insertion in opts, can be
// configured using the platforms and window servers defined in the
// constructor to set reasonable non-Qt defaults for the app stylesheet
QgsSettings settings;
// handle move from old QgsSettings group (/) to new (/qgis/stylesheet)
// NOTE: don't delete old QgsSettings keys, in case user is also running older QGIS
QVariant oldFontPointSize = settings.value( QStringLiteral( "fontPointSize" ) );
QVariant oldFontFamily = settings.value( QStringLiteral( "fontFamily" ) );
settings.beginGroup( QStringLiteral( "qgis/stylesheet" ) );
int fontSize = mDefaultFont.pointSize();
if ( mAndroidOS )
{
// TODO: find a better default fontsize maybe using DPI detection or so (from Marco Bernasocchi commit)
fontSize = 8;
}
if ( oldFontPointSize.isValid() && !settings.value( QStringLiteral( "fontPointSize" ) ).isValid() )
{
fontSize = oldFontPointSize.toInt();
}
QgsDebugMsg( QStringLiteral( "fontPointSize: %1" ).arg( fontSize ) );
opts.insert( QStringLiteral( "fontPointSize" ), settings.value( QStringLiteral( "fontPointSize" ), QVariant( fontSize ) ) );
QString fontFamily = mDefaultFont.family();
if ( oldFontFamily.isValid() && !settings.value( QStringLiteral( "fontFamily" ) ).isValid() )
{
fontFamily = oldFontFamily.toString();
}
fontFamily = settings.value( QStringLiteral( "fontFamily" ), QVariant( fontFamily ) ).toString();
// make sure family exists on system
if ( fontFamily != mDefaultFont.family() )
{
QFont tempFont( fontFamily );
if ( tempFont.family() != fontFamily )
{
// missing from system, drop back to default
fontFamily = mDefaultFont.family();
}
}
QgsDebugMsg( QStringLiteral( "fontFamily: %1" ).arg( fontFamily ) );
opts.insert( QStringLiteral( "fontFamily" ), QVariant( fontFamily ) );
bool gbxCustom = ( mMacStyle );
opts.insert( QStringLiteral( "groupBoxCustom" ), settings.value( QStringLiteral( "groupBoxCustom" ), QVariant( gbxCustom ) ) );
opts.insert( QStringLiteral( "toolbarSpacing" ), settings.value( QStringLiteral( "toolbarSpacing" ), QString() ) );
settings.endGroup(); // "qgis/stylesheet"
opts.insert( QStringLiteral( "iconSize" ), settings.value( QStringLiteral( "/qgis/iconSize" ), QGIS_ICON_SIZE ) );
return opts;
}
void QgsMeasureDialog::restorePosition()
{
QgsSettings settings;
restoreGeometry( settings.value( QStringLiteral( "Windows/Measure/geometry" ) ).toByteArray() );
int wh;
if ( mMeasureArea )
wh = settings.value( QStringLiteral( "Windows/Measure/hNoTable" ), 70 ).toInt();
else
wh = settings.value( QStringLiteral( "Windows/Measure/h" ), 200 ).toInt();
resize( width(), wh );
updateUi();
}
void QgsCptCityArchive::initDefaultArchive()
{
QgsSettings settings;
// use CptCity/baseDir setting if set, default is user dir
QString baseDir = settings.value( QStringLiteral( "CptCity/baseDir" ),
QgsApplication::pkgDataPath() + "/resources" ).toString();
// sub-dir defaults to
QString defArchiveName = settings.value( QStringLiteral( "CptCity/archiveName" ), DEFAULT_CPTCITY_ARCHIVE ).toString();
if ( ! sArchiveRegistry.contains( defArchiveName ) )
initArchive( defArchiveName, baseDir + '/' + defArchiveName );
}
void QgsMapToolCapture::validateGeometry()
{
QgsSettings settings;
if ( settings.value( QStringLiteral( "qgis/digitizing/validate_geometries" ), 1 ).toInt() == 0 )
return;
if ( mValidator )
{
mValidator->deleteLater();
mValidator = nullptr;
}
mGeomErrors.clear();
while ( !mGeomErrorMarkers.isEmpty() )
{
delete mGeomErrorMarkers.takeFirst();
}
QgsGeometry geom;
switch ( mCaptureMode )
{
case CaptureNone:
case CapturePoint:
return;
case CaptureLine:
if ( size() < 2 )
return;
geom = QgsGeometry( mCaptureCurve.curveToLine() );
break;
case CapturePolygon:
if ( size() < 3 )
return;
QgsLineString *exteriorRing = mCaptureCurve.curveToLine();
exteriorRing->close();
QgsPolygon *polygon = new QgsPolygon();
polygon->setExteriorRing( exteriorRing );
geom = QgsGeometry( polygon );
break;
}
if ( geom.isNull() )
return;
QgsGeometry::ValidationMethod method = QgsGeometry::ValidatorQgisInternal;
if ( settings.value( QStringLiteral( "qgis/digitizing/validate_geometries" ), 1 ).toInt() == 2 )
method = QgsGeometry::ValidatorGeos;
mValidator = new QgsGeometryValidator( geom, nullptr, method );
connect( mValidator, &QgsGeometryValidator::errorFound, this, &QgsMapToolCapture::addError );
mValidator->start();
QgsDebugMsgLevel( QStringLiteral( "Validation started" ), 4 );
}
void QgsOwsConnection::addCommonConnectionSettings( QgsDataSourceUri &uri, const QString &key )
{
QgsSettings settings;
if ( settings.value( key + QStringLiteral( "/ignoreAxisOrientation" ), false ).toBool() )
{
uri.setParam( QStringLiteral( "IgnoreAxisOrientation" ), QStringLiteral( "1" ) );
}
if ( settings.value( key + QStringLiteral( "/invertAxisOrientation" ), false ).toBool() )
{
uri.setParam( QStringLiteral( "InvertAxisOrientation" ), QStringLiteral( "1" ) );
}
}
QString QgsCptCityArchive::defaultBaseDir()
{
QString baseDir, archiveName;
QgsSettings settings;
// use CptCity/baseDir setting if set, default is user dir
baseDir = settings.value( QStringLiteral( "CptCity/baseDir" ),
QgsApplication::pkgDataPath() + "/resources" ).toString();
// sub-dir defaults to cpt-city
archiveName = settings.value( QStringLiteral( "CptCity/archiveName" ), DEFAULT_CPTCITY_ARCHIVE ).toString();
return baseDir + '/' + archiveName;
}
QFont QgsCodeEditor::getMonospaceFont()
{
QgsSettings settings;
QString loadFont = settings.value( QStringLiteral( "pythonConsole/fontfamilytextEditor" ), "Monospace" ).toString();
int fontSize = settings.value( QStringLiteral( "pythonConsole/fontsizeEditor" ), 10 ).toInt();
QFont font( loadFont );
font.setFixedPitch( true );
font.setPointSize( fontSize );
font.setStyleHint( QFont::TypeWriter );
font.setBold( false );
return font;
}
QString QgsUserProfileManager::defaultProfileName() const
{
QString defaultName = QStringLiteral( "default" );
// If the profiles.ini doesn't have the default profile we grab it from
// global settings as it might be set by the admin.
// If the overrideProfile flag is set then no matter what the profiles.ini says we always take the
// global profile.
QgsSettings globalSettings;
if ( !mSettings->contains( QStringLiteral( "/core/defaultProfile" ) ) || globalSettings.value( QStringLiteral( "overrideLocalProfile" ), false, QgsSettings::Core ).toBool() )
{
return globalSettings.value( QStringLiteral( "defaultProfile" ), defaultName, QgsSettings::Core ).toString();
}
return mSettings->value( QStringLiteral( "/core/defaultProfile" ), defaultName ).toString();
}
void QgsSnapIndicator::setMatch( const QgsPointLocator::Match &match )
{
mMatch = match;
if ( !mMatch.isValid() )
{
mSnappingMarker.reset();
QToolTip::hideText();
}
else
{
if ( !mSnappingMarker )
{
mSnappingMarker.reset( new QgsVertexMarker( mCanvas ) );
mSnappingMarker->setPenWidth( 3 );
}
QgsSettings s;
QColor color = s.value( QStringLiteral( "/qgis/digitizing/snap_color" ), QColor( Qt::magenta ) ).value<QColor>();
mSnappingMarker->setColor( color );
int iconType;
if ( match.hasVertex() )
{
if ( match.layer() )
iconType = QgsVertexMarker::ICON_BOX; // vertex snap
else
iconType = QgsVertexMarker::ICON_X; // intersection snap
}
else // must be segment snap
{
iconType = QgsVertexMarker::ICON_DOUBLE_TRIANGLE;
}
mSnappingMarker->setIconType( iconType );
mSnappingMarker->setCenter( match.point() );
// tooltip
if ( s.value( QStringLiteral( "/qgis/digitizing/snap_tooltip" ), false ).toBool() )
{
QPoint ptCanvas = mSnappingMarker->toCanvasCoordinates( match.point() ).toPoint();
QPoint ptGlobal = mCanvas->mapToGlobal( ptCanvas );
QRect rect( ptCanvas.x(), ptCanvas.y(), 1, 1 ); // area where is the tooltip valid
QString layerName = match.layer() ? match.layer()->name() : QString();
QToolTip::showText( ptGlobal, layerName, mCanvas, rect );
}
}
}
QgsNamedColorList QgsCustomColorScheme::fetchColors( const QString &context, const QColor &baseColor )
{
Q_UNUSED( context );
Q_UNUSED( baseColor );
//fetch predefined custom colors
QgsNamedColorList colorList;
QgsSettings settings;
//check if settings contains custom palette
if ( !settings.contains( QStringLiteral( "/colors/palettecolors" ) ) )
{
//no custom palette, return default colors
colorList.append( qMakePair( QColor( 0, 0, 0 ), QString() ) );
colorList.append( qMakePair( QColor( 255, 255, 255 ), QString() ) );
colorList.append( qMakePair( QColor( 166, 206, 227 ), QString() ) );
colorList.append( qMakePair( QColor( 31, 120, 180 ), QString() ) );
colorList.append( qMakePair( QColor( 178, 223, 138 ), QString() ) );
colorList.append( qMakePair( QColor( 51, 160, 44 ), QString() ) );
colorList.append( qMakePair( QColor( 251, 154, 153 ), QString() ) );
colorList.append( qMakePair( QColor( 227, 26, 28 ), QString() ) );
colorList.append( qMakePair( QColor( 253, 191, 111 ), QString() ) );
colorList.append( qMakePair( QColor( 255, 127, 0 ), QString() ) );
return colorList;
}
QList< QVariant > customColorVariants = settings.value( QStringLiteral( "colors/palettecolors" ) ).toList();
QList< QVariant > customColorLabels = settings.value( QStringLiteral( "colors/palettelabels" ) ).toList();
//generate list from custom colors
int colorIndex = 0;
for ( QList< QVariant >::iterator it = customColorVariants.begin();
it != customColorVariants.end(); ++it )
{
QColor color = ( *it ).value<QColor>();
QString label;
if ( customColorLabels.length() > colorIndex )
{
label = customColorLabels.at( colorIndex ).toString();
}
colorList.append( qMakePair( color, label ) );
colorIndex++;
}
return colorList;
}
void QgsLayoutPolylineWidget::mEndMarkerToolButton_clicked()
{
QgsSettings s;
QString openDir;
if ( !mEndMarkerLineEdit->text().isEmpty() )
{
QFileInfo fi( mEndMarkerLineEdit->text() );
openDir = fi.dir().absolutePath();
}
if ( openDir.isEmpty() )
{
openDir = s.value( QStringLiteral( "/UI/lastComposerMarkerDir" ), QDir::homePath() ).toString();
}
QString svgFileName = QFileDialog::getOpenFileName( this, tr( "End marker svg file" ), openDir );
if ( !svgFileName.isNull() )
{
QFileInfo fileInfo( svgFileName );
s.setValue( QStringLiteral( "/UI/lastComposerMarkerDir" ), fileInfo.absolutePath() );
mPolyline->beginCommand( tr( "Change End Marker File" ) );
mEndMarkerLineEdit->setText( svgFileName );
mPolyline->endCommand();
}
}
QgsSymbolSelectorDialog::QgsSymbolSelectorDialog( QgsSymbol *symbol, QgsStyle *style, QgsVectorLayer *vl, QWidget *parent, bool embedded )
: QDialog( parent )
{
setLayout( new QVBoxLayout() );
mSelectorWidget = new QgsSymbolSelectorWidget( symbol, style, vl, this );
mButtonBox = new QDialogButtonBox( QDialogButtonBox::Cancel | QDialogButtonBox::Help | QDialogButtonBox::Ok );
connect( mButtonBox, &QDialogButtonBox::accepted, this, &QDialog::accept );
connect( mButtonBox, &QDialogButtonBox::rejected, this, &QDialog::reject );
connect( mButtonBox, &QDialogButtonBox::helpRequested, this, &QgsSymbolSelectorDialog::showHelp );
layout()->addWidget( mSelectorWidget );
layout()->addWidget( mButtonBox );
QgsSettings settings;
restoreGeometry( settings.value( QStringLiteral( "Windows/SymbolSelectorWidget/geometry" ) ).toByteArray() );
// can be embedded in renderer properties dialog
if ( embedded )
{
mButtonBox->hide();
layout()->setContentsMargins( 0, 0, 0, 0 );
}
else
{
setWindowTitle( tr( "Symbol Selector" ) );
}
mSelectorWidget->setDockMode( embedded );
}
void QgsSearchQueryBuilder::saveQuery()
{
QgsSettings s;
QString lastQueryFileDir = s.value( QStringLiteral( "/UI/lastQueryFileDir" ), QDir::homePath() ).toString();
//save as qqt (QGIS query file)
QString saveFileName = QFileDialog::getSaveFileName( nullptr, tr( "Save query to file" ), lastQueryFileDir, QStringLiteral( "*.qqf" ) );
if ( saveFileName.isNull() )
{
return;
}
if ( !saveFileName.endsWith( QLatin1String( ".qqf" ), Qt::CaseInsensitive ) )
{
saveFileName += QLatin1String( ".qqf" );
}
QFile saveFile( saveFileName );
if ( !saveFile.open( QIODevice::WriteOnly | QIODevice::Truncate ) )
{
QMessageBox::critical( nullptr, tr( "Error" ), tr( "Could not open file for writing" ) );
return;
}
QDomDocument xmlDoc;
QDomElement queryElem = xmlDoc.createElement( QStringLiteral( "Query" ) );
QDomText queryTextNode = xmlDoc.createTextNode( txtSQL->text() );
queryElem.appendChild( queryTextNode );
xmlDoc.appendChild( queryElem );
QTextStream fileStream( &saveFile );
xmlDoc.save( fileStream, 2 );
QFileInfo fi( saveFile );
s.setValue( QStringLiteral( "/UI/lastQueryFileDir" ), fi.absolutePath() );
}
QgsMergeAttributesDialog::QgsMergeAttributesDialog( const QgsFeatureList &features, QgsVectorLayer *vl, QgsMapCanvas *canvas, QWidget *parent, Qt::WindowFlags f )
: QDialog( parent, f )
, mFeatureList( features )
, mVectorLayer( vl )
, mMapCanvas( canvas )
{
setupUi( this );
connect( mFromSelectedPushButton, &QPushButton::clicked, this, &QgsMergeAttributesDialog::mFromSelectedPushButton_clicked );
connect( mRemoveFeatureFromSelectionButton, &QPushButton::clicked, this, &QgsMergeAttributesDialog::mRemoveFeatureFromSelectionButton_clicked );
createTableWidgetContents();
QHeaderView *verticalHeader = mTableWidget->verticalHeader();
if ( verticalHeader )
{
connect( mTableWidget, &QTableWidget::itemSelectionChanged, this, &QgsMergeAttributesDialog::selectedRowChanged );
}
mTableWidget->setSelectionBehavior( QAbstractItemView::SelectRows );
mTableWidget->setSelectionMode( QAbstractItemView::SingleSelection );
mFromSelectedPushButton->setIcon( QgsApplication::getThemeIcon( QStringLiteral( "mActionFromSelectedFeature.svg" ) ) );
mRemoveFeatureFromSelectionButton->setIcon( QgsApplication::getThemeIcon( QStringLiteral( "mActionRemoveSelectedFeature.svg" ) ) );
QgsSettings settings;
restoreGeometry( settings.value( QStringLiteral( "Windows/MergeAttributes/geometry" ) ).toByteArray() );
connect( mSkipAllButton, &QAbstractButton::clicked, this, &QgsMergeAttributesDialog::setAllToSkip );
connect( mTableWidget, &QTableWidget::cellChanged, this, &QgsMergeAttributesDialog::tableWidgetCellChanged );
}
void QgsSaveStyleToDbDialog::mFilePickButton_clicked()
{
QgsSettings myQSettings; // where we keep last used filter in persistent state
QString myLastUsedDir = myQSettings.value( QStringLiteral( "style/lastStyleDir" ), QDir::homePath() ).toString();
QString myFileName = QFileDialog::getOpenFileName( this, tr( "Attach Qt Designer UI File" ), myLastUsedDir, tr( "Qt Designer UI file .ui" ) + " (*.ui)" );
if ( myFileName.isNull() )
{
return;
}
QFileInfo myFI( myFileName );
QFile uiFile( myFI.filePath() );
QString myPath = myFI.path();
myQSettings.setValue( QStringLiteral( "style/lastStyleDir" ), myPath );
if ( uiFile.open( QIODevice::ReadOnly ) )
{
QString content( uiFile.readAll() );
QDomDocument doc;
if ( !doc.setContent( content ) || doc.documentElement().tagName().compare( QLatin1String( "ui" ) ) )
{
QMessageBox::warning( this, tr( "Attach UI File" ),
tr( "The selected file does not appear to be a valid Qt Designer UI file." ) );
return;
}
mUIFileContent = content;
mFileNameLabel->setText( myFI.fileName() );
}
}