api/qgslayoutmapgridwidget_8cpp_source.html

/***************************************************************************

                         qgslayoutmapgridwidget.cpp

                         ----------------------------

    begin                : October 2017

    copyright            : (C) 2017 by Nyall Dawson

    email                : nyall dot dawson at gmail dot com

 ***************************************************************************/


/***************************************************************************

 *                                                                         *

 *   This program is free software; you can redistribute it and/or modify  *

 *   it under the terms of the GNU General Public License as published by  *

 *   the Free Software Foundation; either version 2 of the License, or     *

 *   (at your option) any later version.                                   *

 *                                                                         *

 ***************************************************************************/


#include "qgslayoutmapgridwidget.h"


#include "qgsexpressionbuilderdialog.h"

#include "qgslayout.h"

#include "qgslayoutitemmap.h"

#include "qgslayoutreportcontext.h"

#include "qgslinesymbol.h"

#include "qgsmarkersymbol.h"

#include "qgsproject.h"

#include "qgsprojectviewsettings.h"

#include "qgssettingsregistrycore.h"

#include "qgssymbol.h"

#include "qgsvectorlayer.h"


#include "moc_qgslayoutmapgridwidget.cpp"


QgsLayoutMapGridWidget::QgsLayoutMapGridWidget( QgsLayoutItemMapGrid *mapGrid, QgsLayoutItemMap *map )

  : QgsLayoutItemBaseWidget( nullptr, mapGrid )

  , mMap( map )

  , mMapGrid( mapGrid )

{

  setupUi( this );


  mFrameStyleComboBox->addItem( tr( "No Frame" ), QgsLayoutItemMapGrid::NoFrame );

  mFrameStyleComboBox->addItem( tr( "Zebra" ), QgsLayoutItemMapGrid::Zebra );

  mFrameStyleComboBox->addItem( tr( "Zebra (Nautical)" ), QgsLayoutItemMapGrid::ZebraNautical );

  mFrameStyleComboBox->addItem( tr( "Interior Ticks" ), QgsLayoutItemMapGrid::InteriorTicks );

  mFrameStyleComboBox->addItem( tr( "Exterior Ticks" ), QgsLayoutItemMapGrid::ExteriorTicks );

  mFrameStyleComboBox->addItem( tr( "Interior and Exterior Ticks" ), QgsLayoutItemMapGrid::InteriorExteriorTicks );

  mFrameStyleComboBox->addItem( tr( "Line Border" ), QgsLayoutItemMapGrid::LineBorder );

  mFrameStyleComboBox->addItem( tr( "Line Border (Nautical)" ), QgsLayoutItemMapGrid::LineBorderNautical );


  mRotatedTicksLengthModeComboBox->addItem( tr( "Orthogonal" ), QgsLayoutItemMapGrid::OrthogonalTicks );

  mRotatedTicksLengthModeComboBox->addItem( tr( "Fixed Length" ), QgsLayoutItemMapGrid::NormalizedTicks );

  mRotatedAnnotationsLengthModeComboBox->addItem( tr( "Orthogonal" ), QgsLayoutItemMapGrid::OrthogonalTicks );

  mRotatedAnnotationsLengthModeComboBox->addItem( tr( "Fixed Length" ), QgsLayoutItemMapGrid::NormalizedTicks );


  mGridFrameMarginSpinBox->setShowClearButton( true );

  mGridFrameMarginSpinBox->setClearValue( 0 );


  mDistanceToMapFrameSpinBox->setShowClearButton( true );

  mDistanceToMapFrameSpinBox->setClearValue( 0 );


  mOffsetXSpinBox->setShowClearButton( true );

  mOffsetXSpinBox->setClearValue( 0 );

  mOffsetYSpinBox->setShowClearButton( true );

  mOffsetYSpinBox->setClearValue( 0 );


  connect( mIntervalXSpinBox, &QgsDoubleSpinBox::editingFinished, this, &QgsLayoutMapGridWidget::mIntervalXSpinBox_editingFinished );

  connect( mIntervalYSpinBox, &QgsDoubleSpinBox::editingFinished, this, &QgsLayoutMapGridWidget::mIntervalYSpinBox_editingFinished );

  connect( mOffsetXSpinBox, static_cast<void ( QDoubleSpinBox::* )( double )>( &QDoubleSpinBox::valueChanged ), this, &QgsLayoutMapGridWidget::mOffsetXSpinBox_valueChanged );

  connect( mOffsetYSpinBox, static_cast<void ( QDoubleSpinBox::* )( double )>( &QDoubleSpinBox::valueChanged ), this, &QgsLayoutMapGridWidget::mOffsetYSpinBox_valueChanged );

  connect( mCrossWidthSpinBox, static_cast<void ( QDoubleSpinBox::* )( double )>( &QDoubleSpinBox::valueChanged ), this, &QgsLayoutMapGridWidget::mCrossWidthSpinBox_valueChanged );

  connect( mFrameWidthSpinBox, static_cast<void ( QDoubleSpinBox::* )( double )>( &QDoubleSpinBox::valueChanged ), this, &QgsLayoutMapGridWidget::mFrameWidthSpinBox_valueChanged );

  connect( mGridFrameMarginSpinBox, static_cast<void ( QDoubleSpinBox::* )( double )>( &QDoubleSpinBox::valueChanged ), this, &QgsLayoutMapGridWidget::mGridFrameMarginSpinBox_valueChanged );

  connect( mFrameStyleComboBox, static_cast<void ( QComboBox::* )( int )>( &QComboBox::currentIndexChanged ), this, &QgsLayoutMapGridWidget::mFrameStyleComboBox_currentIndexChanged );

  connect( mRotatedTicksGroupBox, &QGroupBox::toggled, this, &QgsLayoutMapGridWidget::mRotatedTicksGroupBox_toggled );

  connect( mRotatedTicksLengthModeComboBox, static_cast<void ( QComboBox::* )( int )>( &QComboBox::currentIndexChanged ), this, &QgsLayoutMapGridWidget::mRotatedTicksLengthModeComboBox_currentIndexChanged );

  connect( mRotatedTicksThresholdSpinBox, static_cast<void ( QDoubleSpinBox::* )( double )>( &QDoubleSpinBox::valueChanged ), this, &QgsLayoutMapGridWidget::mRotatedTicksThresholdSpinBox_valueChanged );

  connect( mRotatedTicksMarginToCornerSpinBox, static_cast<void ( QDoubleSpinBox::* )( double )>( &QDoubleSpinBox::valueChanged ), this, &QgsLayoutMapGridWidget::mRotatedTicksMarginToCornerSpinBox_valueChanged );

  connect( mRotatedAnnotationsGroupBox, &QGroupBox::toggled, this, &QgsLayoutMapGridWidget::mRotatedAnnotationsGroupBox_toggled );

  connect( mRotatedAnnotationsLengthModeComboBox, static_cast<void ( QComboBox::* )( int )>( &QComboBox::currentIndexChanged ), this, &QgsLayoutMapGridWidget::mRotatedAnnotationsLengthModeComboBox_currentIndexChanged );

  connect( mRotatedAnnotationsThresholdSpinBox, static_cast<void ( QDoubleSpinBox::* )( double )>( &QDoubleSpinBox::valueChanged ), this, &QgsLayoutMapGridWidget::mRotatedAnnotationsThresholdSpinBox_valueChanged );

  connect( mRotatedAnnotationsMarginToCornerSpinBox, static_cast<void ( QDoubleSpinBox::* )( double )>( &QDoubleSpinBox::valueChanged ), this, &QgsLayoutMapGridWidget::mRotatedAnnotationsMarginToCornerSpinBox_valueChanged );

  connect( mGridFramePenSizeSpinBox, static_cast<void ( QDoubleSpinBox::* )( double )>( &QDoubleSpinBox::valueChanged ), this, &QgsLayoutMapGridWidget::mGridFramePenSizeSpinBox_valueChanged );

  connect( mGridFramePenColorButton, &QgsColorButton::colorChanged, this, &QgsLayoutMapGridWidget::mGridFramePenColorButton_colorChanged );

  connect( mGridFrameFill1ColorButton, &QgsColorButton::colorChanged, this, &QgsLayoutMapGridWidget::mGridFrameFill1ColorButton_colorChanged );

  connect( mGridFrameFill2ColorButton, &QgsColorButton::colorChanged, this, &QgsLayoutMapGridWidget::mGridFrameFill2ColorButton_colorChanged );

  connect( mGridTypeComboBox, static_cast<void ( QComboBox::* )( int )>( &QComboBox::currentIndexChanged ), this, &QgsLayoutMapGridWidget::mGridTypeComboBox_currentIndexChanged );

  connect( mMapGridUnitComboBox, static_cast<void ( QComboBox::* )( int )>( &QComboBox::currentIndexChanged ), this, &QgsLayoutMapGridWidget::intervalUnitChanged );

  connect( mGridBlendComboBox, static_cast<void ( QComboBox::* )( int )>( &QComboBox::currentIndexChanged ), this, &QgsLayoutMapGridWidget::mGridBlendComboBox_currentIndexChanged );

  connect( mCheckGridLeftSide, &QCheckBox::toggled, this, &QgsLayoutMapGridWidget::mCheckGridLeftSide_toggled );

  connect( mCheckGridRightSide, &QCheckBox::toggled, this, &QgsLayoutMapGridWidget::mCheckGridRightSide_toggled );

  connect( mCheckGridTopSide, &QCheckBox::toggled, this, &QgsLayoutMapGridWidget::mCheckGridTopSide_toggled );

  connect( mCheckGridBottomSide, &QCheckBox::toggled, this, &QgsLayoutMapGridWidget::mCheckGridBottomSide_toggled );

  connect( mFrameDivisionsLeftComboBox, static_cast<void ( QComboBox::* )( int )>( &QComboBox::currentIndexChanged ), this, &QgsLayoutMapGridWidget::mFrameDivisionsLeftComboBox_currentIndexChanged );

  connect( mFrameDivisionsRightComboBox, static_cast<void ( QComboBox::* )( int )>( &QComboBox::currentIndexChanged ), this, &QgsLayoutMapGridWidget::mFrameDivisionsRightComboBox_currentIndexChanged );

  connect( mFrameDivisionsTopComboBox, static_cast<void ( QComboBox::* )( int )>( &QComboBox::currentIndexChanged ), this, &QgsLayoutMapGridWidget::mFrameDivisionsTopComboBox_currentIndexChanged );

  connect( mFrameDivisionsBottomComboBox, static_cast<void ( QComboBox::* )( int )>( &QComboBox::currentIndexChanged ), this, &QgsLayoutMapGridWidget::mFrameDivisionsBottomComboBox_currentIndexChanged );

  connect( mDrawAnnotationGroupBox, &QgsCollapsibleGroupBoxBasic::toggled, this, &QgsLayoutMapGridWidget::mDrawAnnotationGroupBox_toggled );

  connect( mAnnotationFormatButton, &QToolButton::clicked, this, &QgsLayoutMapGridWidget::mAnnotationFormatButton_clicked );

  connect( mAnnotationDisplayLeftComboBox, static_cast<void ( QComboBox::* )( int )>( &QComboBox::currentIndexChanged ), this, &QgsLayoutMapGridWidget::mAnnotationDisplayLeftComboBox_currentIndexChanged );

  connect( mAnnotationDisplayRightComboBox, static_cast<void ( QComboBox::* )( int )>( &QComboBox::currentIndexChanged ), this, &QgsLayoutMapGridWidget::mAnnotationDisplayRightComboBox_currentIndexChanged );

  connect( mAnnotationDisplayTopComboBox, static_cast<void ( QComboBox::* )( int )>( &QComboBox::currentIndexChanged ), this, &QgsLayoutMapGridWidget::mAnnotationDisplayTopComboBox_currentIndexChanged );

  connect( mAnnotationDisplayBottomComboBox, static_cast<void ( QComboBox::* )( int )>( &QComboBox::currentIndexChanged ), this, &QgsLayoutMapGridWidget::mAnnotationDisplayBottomComboBox_currentIndexChanged );

  connect( mAnnotationPositionLeftComboBox, static_cast<void ( QComboBox::* )( int )>( &QComboBox::currentIndexChanged ), this, &QgsLayoutMapGridWidget::mAnnotationPositionLeftComboBox_currentIndexChanged );

  connect( mAnnotationPositionRightComboBox, static_cast<void ( QComboBox::* )( int )>( &QComboBox::currentIndexChanged ), this, &QgsLayoutMapGridWidget::mAnnotationPositionRightComboBox_currentIndexChanged );

  connect( mAnnotationPositionTopComboBox, static_cast<void ( QComboBox::* )( int )>( &QComboBox::currentIndexChanged ), this, &QgsLayoutMapGridWidget::mAnnotationPositionTopComboBox_currentIndexChanged );

  connect( mAnnotationPositionBottomComboBox, static_cast<void ( QComboBox::* )( int )>( &QComboBox::currentIndexChanged ), this, &QgsLayoutMapGridWidget::mAnnotationPositionBottomComboBox_currentIndexChanged );

  connect( mAnnotationDirectionComboBoxLeft, static_cast<void ( QComboBox::* )( int )>( &QComboBox::currentIndexChanged ), this, &QgsLayoutMapGridWidget::mAnnotationDirectionComboBoxLeft_currentIndexChanged );

  connect( mAnnotationDirectionComboBoxRight, static_cast<void ( QComboBox::* )( int )>( &QComboBox::currentIndexChanged ), this, &QgsLayoutMapGridWidget::mAnnotationDirectionComboBoxRight_currentIndexChanged );

  connect( mAnnotationDirectionComboBoxTop, static_cast<void ( QComboBox::* )( int )>( &QComboBox::currentIndexChanged ), this, &QgsLayoutMapGridWidget::mAnnotationDirectionComboBoxTop_currentIndexChanged );

  connect( mAnnotationDirectionComboBoxBottom, static_cast<void ( QComboBox::* )( int )>( &QComboBox::currentIndexChanged ), this, &QgsLayoutMapGridWidget::mAnnotationDirectionComboBoxBottom_currentIndexChanged );

  connect( mAnnotationFormatComboBox, static_cast<void ( QComboBox::* )( int )>( &QComboBox::currentIndexChanged ), this, &QgsLayoutMapGridWidget::mAnnotationFormatComboBox_currentIndexChanged );

  connect( mCoordinatePrecisionSpinBox, static_cast<void ( QSpinBox::* )( int )>( &QSpinBox::valueChanged ), this, &QgsLayoutMapGridWidget::mCoordinatePrecisionSpinBox_valueChanged );

  connect( mDistanceToMapFrameSpinBox, static_cast<void ( QDoubleSpinBox::* )( double )>( &QDoubleSpinBox::valueChanged ), this, &QgsLayoutMapGridWidget::mDistanceToMapFrameSpinBox_valueChanged );

  connect( mMinWidthSpinBox, static_cast<void ( QDoubleSpinBox::* )( double )>( &QDoubleSpinBox::valueChanged ), this, &QgsLayoutMapGridWidget::minIntervalChanged );

  connect( mMaxWidthSpinBox, static_cast<void ( QDoubleSpinBox::* )( double )>( &QDoubleSpinBox::valueChanged ), this, &QgsLayoutMapGridWidget::maxIntervalChanged );

  connect( mEnabledCheckBox, &QCheckBox::toggled, this, &QgsLayoutMapGridWidget::gridEnabledToggled );

  setPanelTitle( tr( "Map Grid Properties" ) );


  mMapGridCrsSelector->setOptionVisible( QgsProjectionSelectionWidget::CrsNotSet, true );

  mMapGridCrsSelector->setNotSetText( tr( "Use Map CRS" ) );

  mMapGridCrsSelector->setDialogTitle( tr( "Grid CRS" ) );


  connect( mMapGridCrsSelector, &QgsProjectionSelectionWidget::crsChanged, this, &QgsLayoutMapGridWidget::mapGridCrsChanged );


  blockAllSignals( true );


  mMapGridUnitComboBox->addItem( tr( "Map Units" ), QgsLayoutItemMapGrid::MapUnit );

  mMapGridUnitComboBox->addItem( tr( "Fit Segment Width" ), QgsLayoutItemMapGrid::DynamicPageSizeBased );

  mMapGridUnitComboBox->addItem( tr( "Millimeters" ), QgsLayoutItemMapGrid::MM );

  mMapGridUnitComboBox->addItem( tr( "Centimeters" ), QgsLayoutItemMapGrid::CM );


  mGridTypeComboBox->insertItem( 0, tr( "Solid" ), QgsLayoutItemMapGrid::Solid );

  mGridTypeComboBox->insertItem( 1, tr( "Cross" ), QgsLayoutItemMapGrid::Cross );

  mGridTypeComboBox->insertItem( 2, tr( "Markers" ), QgsLayoutItemMapGrid::Markers );

  mGridTypeComboBox->insertItem( 3, tr( "Frame and annotations only" ), QgsLayoutItemMapGrid::FrameAnnotationsOnly );


  insertFrameDisplayEntries( mFrameDivisionsLeftComboBox );

  insertFrameDisplayEntries( mFrameDivisionsRightComboBox );

  insertFrameDisplayEntries( mFrameDivisionsTopComboBox );

  insertFrameDisplayEntries( mFrameDivisionsBottomComboBox );


  insertAnnotationDisplayEntries( mAnnotationDisplayLeftComboBox );

  insertAnnotationDisplayEntries( mAnnotationDisplayRightComboBox );

  insertAnnotationDisplayEntries( mAnnotationDisplayTopComboBox );

  insertAnnotationDisplayEntries( mAnnotationDisplayBottomComboBox );


  insertAnnotationPositionEntries( mAnnotationPositionLeftComboBox );

  insertAnnotationPositionEntries( mAnnotationPositionRightComboBox );

  insertAnnotationPositionEntries( mAnnotationPositionTopComboBox );

  insertAnnotationPositionEntries( mAnnotationPositionBottomComboBox );


  insertAnnotationDirectionEntries( mAnnotationDirectionComboBoxLeft );

  insertAnnotationDirectionEntries( mAnnotationDirectionComboBoxRight );

  insertAnnotationDirectionEntries( mAnnotationDirectionComboBoxTop );

  insertAnnotationDirectionEntries( mAnnotationDirectionComboBoxBottom );


  mGridFramePenColorButton->setColorDialogTitle( tr( "Select Grid Frame Color" ) );

  mGridFramePenColorButton->setAllowOpacity( true );

  mGridFramePenColorButton->setContext( QStringLiteral( "composer" ) );

  mGridFramePenColorButton->setNoColorString( tr( "Transparent Frame" ) );

  mGridFramePenColorButton->setShowNoColor( true );


  mGridFrameFill1ColorButton->setColorDialogTitle( tr( "Select Grid Frame Fill Color" ) );

  mGridFrameFill1ColorButton->setAllowOpacity( true );

  mGridFrameFill1ColorButton->setContext( QStringLiteral( "composer" ) );

  mGridFrameFill1ColorButton->setNoColorString( tr( "Transparent Fill" ) );

  mGridFrameFill1ColorButton->setShowNoColor( true );


  mGridFrameFill2ColorButton->setColorDialogTitle( tr( "Select Grid Frame Fill Color" ) );

  mGridFrameFill2ColorButton->setAllowOpacity( true );

  mGridFrameFill2ColorButton->setContext( QStringLiteral( "composer" ) );

  mGridFrameFill2ColorButton->setNoColorString( tr( "Transparent Fill" ) );

  mGridFrameFill2ColorButton->setShowNoColor( true );


  mGridLineStyleButton->setSymbolType( Qgis::SymbolType::Line );

  mGridMarkerStyleButton->setSymbolType( Qgis::SymbolType::Marker );


  //set initial state of frame style controls

  toggleFrameControls( false, false, false, false );


  registerDataDefinedButton( mEnabledDDBtn, QgsLayoutObject::DataDefinedProperty::MapGridEnabled );

  registerDataDefinedButton( mIntervalXDDBtn, QgsLayoutObject::DataDefinedProperty::MapGridIntervalX );

  registerDataDefinedButton( mIntervalYDDBtn, QgsLayoutObject::DataDefinedProperty::MapGridIntervalY );

  registerDataDefinedButton( mOffsetXDDBtn, QgsLayoutObject::DataDefinedProperty::MapGridOffsetX );

  registerDataDefinedButton( mOffsetYDDBtn, QgsLayoutObject::DataDefinedProperty::MapGridOffsetY );

  registerDataDefinedButton( mFrameSizeDDBtn, QgsLayoutObject::DataDefinedProperty::MapGridFrameSize );

  registerDataDefinedButton( mFrameMarginDDBtn, QgsLayoutObject::DataDefinedProperty::MapGridFrameMargin );

  registerDataDefinedButton( mLabelDistDDBtn, QgsLayoutObject::DataDefinedProperty::MapGridLabelDistance );

  registerDataDefinedButton( mCrossWidthDDBtn, QgsLayoutObject::DataDefinedProperty::MapGridCrossSize );

  registerDataDefinedButton( mFrameLineThicknessDDBtn, QgsLayoutObject::DataDefinedProperty::MapGridFrameLineThickness );

  registerDataDefinedButton( mAnnotationDisplayLeftDDBtn, QgsLayoutObject::DataDefinedProperty::MapGridAnnotationDisplayLeft );

  registerDataDefinedButton( mAnnotationDisplayRightDDBtn, QgsLayoutObject::DataDefinedProperty::MapGridAnnotationDisplayRight );

  registerDataDefinedButton( mAnnotationDisplayTopDDBtn, QgsLayoutObject::DataDefinedProperty::MapGridAnnotationDisplayTop );

  registerDataDefinedButton( mAnnotationDisplayBottomDDBtn, QgsLayoutObject::DataDefinedProperty::MapGridAnnotationDisplayBottom );

  registerDataDefinedButton( mFrameDivisionsLeftDDBtn, QgsLayoutObject::DataDefinedProperty::MapGridFrameDivisionsLeft );

  registerDataDefinedButton( mFrameDivisionsRightDDBtn, QgsLayoutObject::DataDefinedProperty::MapGridFrameDivisionsRight );

  registerDataDefinedButton( mFrameDivisionsTopDDBtn, QgsLayoutObject::DataDefinedProperty::MapGridFrameDivisionsTop );

  registerDataDefinedButton( mFrameDivisionsBottomDDBtn, QgsLayoutObject::DataDefinedProperty::MapGridFrameDivisionsBottom );

  registerDataDefinedButton( mDrawAnnotationDDBtn, QgsLayoutObject::DataDefinedProperty::MapGridDrawAnnotation );


  // call to initially populate mAnnotationFormatComboBox

  onCrsChanged();


  updateGuiElements();


  blockAllSignals( false );

  connect( mAnnotationFontButton, &QgsFontButton::changed, this, &QgsLayoutMapGridWidget::annotationTextFormatChanged );

  connect( mGridLineStyleButton, &QgsSymbolButton::changed, this, &QgsLayoutMapGridWidget::lineSymbolChanged );

  connect( mGridMarkerStyleButton, &QgsSymbolButton::changed, this, &QgsLayoutMapGridWidget::markerSymbolChanged );


  mGridLineStyleButton->registerExpressionContextGenerator( mMapGrid );

  mGridLineStyleButton->setLayer( coverageLayer() );

  mGridMarkerStyleButton->registerExpressionContextGenerator( mMapGrid );

  mGridMarkerStyleButton->setLayer( coverageLayer() );

  if ( mMap->layout() )

  {

    connect( &mMap->layout()->reportContext(), &QgsLayoutReportContext::layerChanged, mGridLineStyleButton, &QgsSymbolButton::setLayer );

    connect( &mMap->layout()->reportContext(), &QgsLayoutReportContext::layerChanged, mGridMarkerStyleButton, &QgsSymbolButton::setLayer );

    connect( &mMap->layout()->reportContext(), &QgsLayoutReportContext::layerChanged, mAnnotationFontButton, &QgsFontButton::setLayer );

  }

  mAnnotationFontButton->setLayer( coverageLayer() );

  mAnnotationFontButton->registerExpressionContextGenerator( mMapGrid );


  connect( mMapGrid, &QgsLayoutItemMapGrid::crsChanged, this, &QgsLayoutMapGridWidget::onCrsChanged );

}


void QgsLayoutMapGridWidget::populateDataDefinedButtons()

{

  updateDataDefinedButton( mEnabledDDBtn );

  updateDataDefinedButton( mIntervalXDDBtn );

  updateDataDefinedButton( mIntervalYDDBtn );

  updateDataDefinedButton( mOffsetXDDBtn );

  updateDataDefinedButton( mOffsetYDDBtn );

  updateDataDefinedButton( mFrameSizeDDBtn );

  updateDataDefinedButton( mFrameMarginDDBtn );

  updateDataDefinedButton( mLabelDistDDBtn );

  updateDataDefinedButton( mCrossWidthDDBtn );

  updateDataDefinedButton( mFrameLineThicknessDDBtn );

  updateDataDefinedButton( mAnnotationDisplayLeftDDBtn );

  updateDataDefinedButton( mAnnotationDisplayRightDDBtn );

  updateDataDefinedButton( mAnnotationDisplayTopDDBtn );

  updateDataDefinedButton( mAnnotationDisplayBottomDDBtn );

  updateDataDefinedButton( mFrameDivisionsLeftDDBtn );

  updateDataDefinedButton( mFrameDivisionsRightDDBtn );

  updateDataDefinedButton( mFrameDivisionsTopDDBtn );

  updateDataDefinedButton( mFrameDivisionsBottomDDBtn );

}


void QgsLayoutMapGridWidget::setGuiElementValues()

{

  updateGuiElements();

}


void QgsLayoutMapGridWidget::updateGuiElements()

{

  if ( !mMapGrid || !mMap )

  {

    return;

  }


  blockAllSignals( true );

  populateDataDefinedButtons();

  setGridItems();

  blockAllSignals( false );

}


void QgsLayoutMapGridWidget::blockAllSignals( bool block )

{

  //grid

  mEnabledCheckBox->blockSignals( block );

  mGridTypeComboBox->blockSignals( block );

  mIntervalXSpinBox->blockSignals( block );

  mIntervalYSpinBox->blockSignals( block );

  mOffsetXSpinBox->blockSignals( block );

  mOffsetYSpinBox->blockSignals( block );

  mCrossWidthSpinBox->blockSignals( block );

  mFrameStyleComboBox->blockSignals( block );

  mFrameWidthSpinBox->blockSignals( block );

  mGridFrameMarginSpinBox->blockSignals( block );

  mGridLineStyleButton->blockSignals( block );

  mMapGridUnitComboBox->blockSignals( block );

  mGridFramePenSizeSpinBox->blockSignals( block );

  mGridFramePenColorButton->blockSignals( block );

  mGridFrameFill1ColorButton->blockSignals( block );

  mGridFrameFill2ColorButton->blockSignals( block );

  mGridBlendComboBox->blockSignals( block );

  mCheckGridLeftSide->blockSignals( block );

  mCheckGridRightSide->blockSignals( block );

  mCheckGridTopSide->blockSignals( block );

  mCheckGridBottomSide->blockSignals( block );

  mFrameDivisionsLeftComboBox->blockSignals( block );

  mFrameDivisionsRightComboBox->blockSignals( block );

  mFrameDivisionsTopComboBox->blockSignals( block );

  mFrameDivisionsBottomComboBox->blockSignals( block );

  mGridMarkerStyleButton->blockSignals( block );


  //grid annotation

  mDrawAnnotationGroupBox->blockSignals( block );

  mAnnotationFormatComboBox->blockSignals( block );

  mAnnotationDisplayLeftComboBox->blockSignals( block );

  mAnnotationPositionLeftComboBox->blockSignals( block );

  mAnnotationDirectionComboBoxLeft->blockSignals( block );

  mAnnotationDisplayRightComboBox->blockSignals( block );

  mAnnotationPositionRightComboBox->blockSignals( block );

  mAnnotationDirectionComboBoxRight->blockSignals( block );

  mAnnotationDisplayTopComboBox->blockSignals( block );

  mAnnotationPositionTopComboBox->blockSignals( block );

  mAnnotationDirectionComboBoxTop->blockSignals( block );

  mAnnotationDisplayBottomComboBox->blockSignals( block );

  mAnnotationPositionBottomComboBox->blockSignals( block );

  mAnnotationDirectionComboBoxBottom->blockSignals( block );

  mDistanceToMapFrameSpinBox->blockSignals( block );

  mCoordinatePrecisionSpinBox->blockSignals( block );

  mAnnotationFontButton->blockSignals( block );

  mMinWidthSpinBox->blockSignals( block );

  mMaxWidthSpinBox->blockSignals( block );

}


void QgsLayoutMapGridWidget::handleChangedFrameDisplay( QgsLayoutItemMapGrid::BorderSide border, const QgsLayoutItemMapGrid::DisplayMode mode )

{

  if ( !mMapGrid || !mMap )

  {

    return;

  }


  mMap->beginCommand( tr( "Change Frame Divisions" ) );

  mMapGrid->setFrameDivisions( mode, border );

  mMap->endCommand();

  mMap->updateBoundingRect();

}


void QgsLayoutMapGridWidget::handleChangedAnnotationDisplay( QgsLayoutItemMapGrid::BorderSide border, const QgsLayoutItemMapGrid::DisplayMode mode )

{

  if ( !mMapGrid || !mMap )

  {

    return;

  }


  mMap->beginCommand( tr( "Change Annotation Format" ) );

  mMapGrid->setAnnotationDisplay( mode, border );

  mMap->updateBoundingRect();

  mMap->update();

  mMap->endCommand();

}


void QgsLayoutMapGridWidget::toggleFrameControls( bool frameEnabled, bool frameFillEnabled, bool frameSizeEnabled, bool rotationEnabled )

{

  //set status of frame controls

  mFrameWidthSpinBox->setEnabled( frameSizeEnabled );

  mGridFrameMarginSpinBox->setEnabled( frameEnabled );

  mGridFramePenSizeSpinBox->setEnabled( frameEnabled );

  mGridFramePenColorButton->setEnabled( frameEnabled );

  mGridFrameFill1ColorButton->setEnabled( frameFillEnabled );

  mGridFrameFill2ColorButton->setEnabled( frameFillEnabled );

  mFrameWidthLabel->setEnabled( frameSizeEnabled );

  mFrameMarginLabel->setEnabled( frameEnabled );

  mFramePenLabel->setEnabled( frameEnabled );

  mFrameFillLabel->setEnabled( frameFillEnabled );

  mCheckGridLeftSide->setEnabled( frameEnabled );

  mCheckGridRightSide->setEnabled( frameEnabled );

  mCheckGridTopSide->setEnabled( frameEnabled );

  mCheckGridBottomSide->setEnabled( frameEnabled );

  mFrameDivisionsLeftComboBox->setEnabled( frameEnabled );

  mFrameDivisionsRightComboBox->setEnabled( frameEnabled );

  mFrameDivisionsTopComboBox->setEnabled( frameEnabled );

  mFrameDivisionsBottomComboBox->setEnabled( frameEnabled );

  mLeftDivisionsLabel->setEnabled( frameEnabled );

  mRightDivisionsLabel->setEnabled( frameEnabled );

  mTopDivisionsLabel->setEnabled( frameEnabled );

  mBottomDivisionsLabel->setEnabled( frameEnabled );

  mRotatedTicksGroupBox->setEnabled( rotationEnabled );

}


void QgsLayoutMapGridWidget::insertAnnotationPositionEntries( QComboBox *c )

{

  c->insertItem( 0, tr( "Inside Frame" ), QgsLayoutItemMapGrid::InsideMapFrame );

  c->insertItem( 1, tr( "Outside Frame" ), QgsLayoutItemMapGrid::OutsideMapFrame );

}


void QgsLayoutMapGridWidget::insertAnnotationDirectionEntries( QComboBox *c )

{

  c->addItem( tr( "Horizontal" ), QgsLayoutItemMapGrid::Horizontal );

  c->addItem( tr( "Vertical Ascending" ), QgsLayoutItemMapGrid::Vertical );

  c->addItem( tr( "Vertical Descending" ), QgsLayoutItemMapGrid::VerticalDescending );

  c->addItem( tr( "Boundary Direction" ), QgsLayoutItemMapGrid::BoundaryDirection );

  // c->addItem( tr( "Parallel to Tick" ), QgsLayoutItemMapGrid::ParallelToTick );

  c->addItem( tr( "Above Tick" ), QgsLayoutItemMapGrid::AboveTick );

  c->addItem( tr( "On Tick" ), QgsLayoutItemMapGrid::OnTick );

  c->addItem( tr( "Under Tick" ), QgsLayoutItemMapGrid::UnderTick );

}


void QgsLayoutMapGridWidget::initFrameDisplayBox( QComboBox *c, QgsLayoutItemMapGrid::DisplayMode display )

{

  if ( !c )

  {

    return;

  }

  c->setCurrentIndex( c->findData( display ) );

}


void QgsLayoutMapGridWidget::handleChangedAnnotationPosition( QgsLayoutItemMapGrid::BorderSide border, const QgsLayoutItemMapGrid::AnnotationPosition position )

{

  if ( !mMapGrid || !mMap )

  {

    return;

  }


  mMap->beginCommand( tr( "Change Annotation Position" ) );

  mMapGrid->setAnnotationPosition( position, border );


  mMap->updateBoundingRect();

  mMap->update();

  mMap->endCommand();

}


void QgsLayoutMapGridWidget::handleChangedAnnotationDirection( QgsLayoutItemMapGrid::BorderSide border, QgsLayoutItemMapGrid::AnnotationDirection direction )

{

  if ( !mMapGrid || !mMap )

  {

    return;

  }


  mMap->beginCommand( tr( "Change Annotation Direction" ) );

  mMapGrid->setAnnotationDirection( direction, border );

  mMap->updateBoundingRect();

  mMap->update();

  mMap->endCommand();

}


void QgsLayoutMapGridWidget::insertFrameDisplayEntries( QComboBox *c )

{

  c->addItem( tr( "All" ), QgsLayoutItemMapGrid::ShowAll );

  c->addItem( tr( "Latitude/Y Only" ), QgsLayoutItemMapGrid::LatitudeOnly );

  c->addItem( tr( "Longitude/X Only" ), QgsLayoutItemMapGrid::LongitudeOnly );

}


void QgsLayoutMapGridWidget::insertAnnotationDisplayEntries( QComboBox *c )

{

  c->insertItem( 0, tr( "Show All" ), QgsLayoutItemMapGrid::ShowAll );

  c->insertItem( 1, tr( "Show Latitude/Y Only" ), QgsLayoutItemMapGrid::LatitudeOnly );

  c->insertItem( 2, tr( "Show Longitude/X Only" ), QgsLayoutItemMapGrid::LongitudeOnly );

  c->insertItem( 3, tr( "Disabled" ), QgsLayoutItemMapGrid::HideAll );

}


void QgsLayoutMapGridWidget::initAnnotationPositionBox( QComboBox *c, QgsLayoutItemMapGrid::AnnotationPosition pos )

{

  if ( !c )

  {

    return;

  }


  if ( pos == QgsLayoutItemMapGrid::InsideMapFrame )

  {

    c->setCurrentIndex( c->findText( tr( "Inside Frame" ) ) );

  }

  else

  {

    c->setCurrentIndex( c->findText( tr( "Outside Frame" ) ) );

  }

}


void QgsLayoutMapGridWidget::initAnnotationDirectionBox( QComboBox *c, QgsLayoutItemMapGrid::AnnotationDirection dir )

{

  if ( !c )

  {

    return;

  }

  c->setCurrentIndex( c->findData( dir ) );

}


bool QgsLayoutMapGridWidget::hasPredefinedScales() const

{

  // first look at project's scales

  const QVector<double> scales = QgsProject::instance()->viewSettings()->mapScales();

  const bool hasProjectScales( QgsProject::instance()->viewSettings()->useProjectScales() );

  if ( !hasProjectScales || scales.isEmpty() )

  {

    // default to global map tool scales

    const QStringList scales = QgsSettingsRegistryCore::settingsMapScales->value();

    return !scales.isEmpty() && !scales[0].isEmpty();

  }

  return true;

}


void QgsLayoutMapGridWidget::setGridItems()

{

  if ( !mMapGrid )

  {

    return;

  }


  mGridMarkerStyleButton->registerExpressionContextGenerator( mMapGrid );

  mGridLineStyleButton->registerExpressionContextGenerator( mMapGrid );

  mAnnotationFontButton->registerExpressionContextGenerator( mMapGrid );


  mEnabledCheckBox->setChecked( mMapGrid->enabled() );

  mIntervalXSpinBox->setValue( mMapGrid->intervalX() );

  mIntervalYSpinBox->setValue( mMapGrid->intervalY() );

  mOffsetXSpinBox->setValue( mMapGrid->offsetX() );

  mOffsetYSpinBox->setValue( mMapGrid->offsetY() );

  mCrossWidthSpinBox->setValue( mMapGrid->crossLength() );

  mFrameWidthSpinBox->setValue( mMapGrid->frameWidth() );

  mGridFrameMarginSpinBox->setValue( mMapGrid->frameMargin() );

  mGridFramePenSizeSpinBox->setValue( mMapGrid->framePenSize() );

  mGridFramePenColorButton->setColor( mMapGrid->framePenColor() );

  mGridFrameFill1ColorButton->setColor( mMapGrid->frameFillColor1() );

  mGridFrameFill2ColorButton->setColor( mMapGrid->frameFillColor2() );


  const QgsLayoutItemMapGrid::GridStyle gridStyle = mMapGrid->style();

  mGridTypeComboBox->setCurrentIndex( mGridTypeComboBox->findData( gridStyle ) );

  switch ( gridStyle )

  {

    case QgsLayoutItemMapGrid::Cross:

      mCrossWidthSpinBox->setVisible( true );

      mCrossWidthDDBtn->setVisible( true );

      mCrossWidthLabel->setVisible( true );

      mGridLineStyleButton->setVisible( true );

      mLineStyleLabel->setVisible( true );

      mGridMarkerStyleButton->setVisible( false );

      mMarkerStyleLabel->setVisible( false );

      mGridBlendComboBox->setVisible( true );

      mGridBlendLabel->setVisible( true );

      break;

    case QgsLayoutItemMapGrid::Markers:

      mCrossWidthSpinBox->setVisible( false );

      mCrossWidthDDBtn->setVisible( false );

      mCrossWidthLabel->setVisible( false );

      mGridLineStyleButton->setVisible( false );

      mLineStyleLabel->setVisible( false );

      mGridMarkerStyleButton->setVisible( true );

      mMarkerStyleFrame->setVisible( true );

      mMarkerStyleLabel->setVisible( true );

      mGridBlendComboBox->setVisible( true );

      mGridBlendLabel->setVisible( true );

      break;

    case QgsLayoutItemMapGrid::Solid:

      mCrossWidthSpinBox->setVisible( false );

      mCrossWidthDDBtn->setVisible( false );

      mCrossWidthLabel->setVisible( false );

      mGridLineStyleButton->setVisible( true );

      mLineStyleLabel->setVisible( true );

      mGridMarkerStyleButton->setVisible( false );

      mMarkerStyleFrame->setVisible( false );

      mMarkerStyleLabel->setVisible( false );

      mGridBlendComboBox->setVisible( true );

      mGridBlendLabel->setVisible( true );

      break;

    case QgsLayoutItemMapGrid::FrameAnnotationsOnly:

      mCrossWidthSpinBox->setVisible( false );

      mCrossWidthDDBtn->setVisible( false );

      mCrossWidthLabel->setVisible( false );

      mGridLineStyleButton->setVisible( false );

      mLineStyleLabel->setVisible( false );

      mGridMarkerStyleButton->setVisible( false );

      mMarkerStyleFrame->setVisible( false );

      mMarkerStyleLabel->setVisible( false );

      mGridBlendComboBox->setVisible( false );

      mGridBlendLabel->setVisible( false );

      break;

  }


  //grid frame

  mFrameWidthSpinBox->setValue( mMapGrid->frameWidth() );

  mGridFrameMarginSpinBox->setValue( mMapGrid->frameMargin() );

  const QgsLayoutItemMapGrid::FrameStyle gridFrameStyle = mMapGrid->frameStyle();

  mFrameStyleComboBox->setCurrentIndex( mFrameStyleComboBox->findData( gridFrameStyle ) );

  switch ( gridFrameStyle )

  {

    case QgsLayoutItemMapGrid::Zebra:

    case QgsLayoutItemMapGrid::ZebraNautical:

      toggleFrameControls( true, true, true, false );

      break;

    case QgsLayoutItemMapGrid::InteriorTicks:

    case QgsLayoutItemMapGrid::ExteriorTicks:

    case QgsLayoutItemMapGrid::InteriorExteriorTicks:

      toggleFrameControls( true, false, true, true );

      break;

    case QgsLayoutItemMapGrid::LineBorder:

    case QgsLayoutItemMapGrid::LineBorderNautical:

      toggleFrameControls( true, false, false, false );

      break;

    case QgsLayoutItemMapGrid::NoFrame:

      toggleFrameControls( false, false, false, false );

      break;

  }


  mCheckGridLeftSide->setChecked( mMapGrid->testFrameSideFlag( QgsLayoutItemMapGrid::FrameLeft ) );

  mCheckGridRightSide->setChecked( mMapGrid->testFrameSideFlag( QgsLayoutItemMapGrid::FrameRight ) );

  mCheckGridTopSide->setChecked( mMapGrid->testFrameSideFlag( QgsLayoutItemMapGrid::FrameTop ) );

  mCheckGridBottomSide->setChecked( mMapGrid->testFrameSideFlag( QgsLayoutItemMapGrid::FrameBottom ) );


  mRotatedTicksGroupBox->setChecked( mMapGrid->rotatedTicksEnabled() );

  mRotatedTicksLengthModeComboBox->setCurrentIndex( mRotatedTicksLengthModeComboBox->findData( mMapGrid->rotatedTicksLengthMode() ) );

  mRotatedTicksThresholdSpinBox->setValue( mMapGrid->rotatedTicksMinimumAngle() );

  mRotatedTicksMarginToCornerSpinBox->setValue( mMapGrid->rotatedTicksMarginToCorner() );


  mRotatedAnnotationsGroupBox->setChecked( mMapGrid->rotatedAnnotationsEnabled() );

  mRotatedAnnotationsLengthModeComboBox->setCurrentIndex( mRotatedAnnotationsLengthModeComboBox->findData( mMapGrid->rotatedAnnotationsLengthMode() ) );

  mRotatedAnnotationsThresholdSpinBox->setValue( mMapGrid->rotatedAnnotationsMinimumAngle() );

  mRotatedAnnotationsMarginToCornerSpinBox->setValue( mMapGrid->rotatedAnnotationsMarginToCorner() );


  initFrameDisplayBox( mFrameDivisionsLeftComboBox, mMapGrid->frameDivisions( QgsLayoutItemMapGrid::Left ) );

  initFrameDisplayBox( mFrameDivisionsRightComboBox, mMapGrid->frameDivisions( QgsLayoutItemMapGrid::Right ) );

  initFrameDisplayBox( mFrameDivisionsTopComboBox, mMapGrid->frameDivisions( QgsLayoutItemMapGrid::Top ) );

  initFrameDisplayBox( mFrameDivisionsBottomComboBox, mMapGrid->frameDivisions( QgsLayoutItemMapGrid::Bottom ) );


  //line style

  mGridLineStyleButton->setSymbol( mMapGrid->lineSymbol()->clone() );

  //marker style

  mGridMarkerStyleButton->setSymbol( mMapGrid->markerSymbol()->clone() );


  mGridBlendComboBox->setBlendMode( mMapGrid->blendMode() );


  mDrawAnnotationGroupBox->setChecked( mMapGrid->annotationEnabled() );

  mAnnotationDisplayLeftComboBox->setCurrentIndex( mAnnotationDisplayLeftComboBox->findData( mMapGrid->annotationDisplay( QgsLayoutItemMapGrid::Left ) ) );

  mAnnotationDisplayRightComboBox->setCurrentIndex( mAnnotationDisplayRightComboBox->findData( mMapGrid->annotationDisplay( QgsLayoutItemMapGrid::Right ) ) );

  mAnnotationDisplayTopComboBox->setCurrentIndex( mAnnotationDisplayTopComboBox->findData( mMapGrid->annotationDisplay( QgsLayoutItemMapGrid::Top ) ) );

  mAnnotationDisplayBottomComboBox->setCurrentIndex( mAnnotationDisplayBottomComboBox->findData( mMapGrid->annotationDisplay( QgsLayoutItemMapGrid::Bottom ) ) );


  mAnnotationPositionLeftComboBox->setCurrentIndex( mAnnotationPositionLeftComboBox->findData( mMapGrid->annotationPosition( QgsLayoutItemMapGrid::Left ) ) );

  mAnnotationPositionRightComboBox->setCurrentIndex( mAnnotationPositionRightComboBox->findData( mMapGrid->annotationPosition( QgsLayoutItemMapGrid::Right ) ) );

  mAnnotationPositionTopComboBox->setCurrentIndex( mAnnotationPositionTopComboBox->findData( mMapGrid->annotationPosition( QgsLayoutItemMapGrid::Top ) ) );

  mAnnotationPositionBottomComboBox->setCurrentIndex( mAnnotationPositionBottomComboBox->findData( mMapGrid->annotationPosition( QgsLayoutItemMapGrid::Bottom ) ) );


  initAnnotationDirectionBox( mAnnotationDirectionComboBoxLeft, mMapGrid->annotationDirection( QgsLayoutItemMapGrid::Left ) );

  initAnnotationDirectionBox( mAnnotationDirectionComboBoxRight, mMapGrid->annotationDirection( QgsLayoutItemMapGrid::Right ) );

  initAnnotationDirectionBox( mAnnotationDirectionComboBoxTop, mMapGrid->annotationDirection( QgsLayoutItemMapGrid::Top ) );

  initAnnotationDirectionBox( mAnnotationDirectionComboBoxBottom, mMapGrid->annotationDirection( QgsLayoutItemMapGrid::Bottom ) );


  mAnnotationFontButton->setDialogTitle( tr( "Grid Annotation Font" ) );

  mAnnotationFontButton->setMode( QgsFontButton::ModeTextRenderer );

  mAnnotationFontButton->setTextFormat( mMapGrid->annotationTextFormat() );


  mAnnotationFormatComboBox->setCurrentIndex( mAnnotationFormatComboBox->findData( mMapGrid->annotationFormat() ) );

  mAnnotationFormatButton->setEnabled( mMapGrid->annotationFormat() == QgsLayoutItemMapGrid::CustomFormat );

  mDistanceToMapFrameSpinBox->setValue( mMapGrid->annotationFrameDistance() );

  mCoordinatePrecisionSpinBox->setValue( mMapGrid->annotationPrecision() );


  //Unit

  mMapGridUnitComboBox->setCurrentIndex( mMapGridUnitComboBox->findData( mMapGrid->units() ) );

  switch ( mMapGrid->units() )

  {

    case QgsLayoutItemMapGrid::MapUnit:

    case QgsLayoutItemMapGrid::MM:

    case QgsLayoutItemMapGrid::CM:

      mIntervalStackedWidget->setCurrentIndex( 0 );

      break;


    case QgsLayoutItemMapGrid::DynamicPageSizeBased:

      mIntervalStackedWidget->setCurrentIndex( 1 );

      break;

  }

  mMinWidthSpinBox->setValue( mMapGrid->minimumIntervalWidth() );

  mMaxWidthSpinBox->setValue( mMapGrid->maximumIntervalWidth() );


  whileBlocking( mMapGridCrsSelector )->setCrs( mMapGrid->crs() );

}


void QgsLayoutMapGridWidget::mIntervalXSpinBox_editingFinished()

{

  if ( !mMapGrid || !mMap )

  {

    return;

  }


  mMap->beginCommand( tr( "Change Grid Interval" ) );

  mMapGrid->setIntervalX( mIntervalXSpinBox->value() );

  mMap->updateBoundingRect();

  mMap->update();

  mMap->endCommand();

}


void QgsLayoutMapGridWidget::mIntervalYSpinBox_editingFinished()

{

  if ( !mMapGrid || !mMap )

  {

    return;

  }


  mMap->beginCommand( tr( "Change Grid Interval" ) );

  mMapGrid->setIntervalY( mIntervalYSpinBox->value() );

  mMap->updateBoundingRect();

  mMap->update();

  mMap->endCommand();

}


void QgsLayoutMapGridWidget::mOffsetXSpinBox_valueChanged( double value )

{

  if ( !mMapGrid || !mMap )

  {

    return;

  }


  mMap->beginCommand( tr( "Change Grid Offset" ) );

  mMapGrid->setOffsetX( value );

  mMap->updateBoundingRect();

  mMap->update();

  mMap->endCommand();

}


void QgsLayoutMapGridWidget::mOffsetYSpinBox_valueChanged( double value )

{

  if ( !mMapGrid || !mMap )

  {

    return;

  }


  mMap->beginCommand( tr( "Change Grid Offset" ) );

  mMapGrid->setOffsetY( value );

  mMap->updateBoundingRect();

  mMap->update();

  mMap->endCommand();

}


void QgsLayoutMapGridWidget::mCrossWidthSpinBox_valueChanged( double val )

{

  if ( !mMapGrid || !mMap )

  {

    return;

  }


  mMap->beginCommand( tr( "Change Cross Width" ) );

  mMapGrid->setCrossLength( val );

  mMap->update();

  mMap->endCommand();

}


void QgsLayoutMapGridWidget::mFrameWidthSpinBox_valueChanged( double val )

{

  if ( !mMapGrid || !mMap )

  {

    return;

  }


  mMap->beginCommand( tr( "Change Frame Width" ) );

  mMapGrid->setFrameWidth( val );

  mMap->updateBoundingRect();

  mMap->update();

  mMap->endCommand();

}


void QgsLayoutMapGridWidget::mGridFrameMarginSpinBox_valueChanged( double val )

{

  if ( !mMapGrid || !mMap )

  {

    return;

  }


  mMap->beginCommand( tr( "Change Grid Frame Margin" ) );

  mMapGrid->setFrameMargin( val );

  mMap->updateBoundingRect();

  mMap->update();

  mMap->endCommand();

}


void QgsLayoutMapGridWidget::mCheckGridLeftSide_toggled( bool checked )

{

  if ( !mMapGrid || !mMap )

  {

    return;

  }


  mMap->beginCommand( tr( "Change Frame Left" ) );

  mMapGrid->setFrameSideFlag( QgsLayoutItemMapGrid::FrameLeft, checked );

  mMap->updateBoundingRect();

  mMap->update();

  mMap->endCommand();

}


void QgsLayoutMapGridWidget::mCheckGridRightSide_toggled( bool checked )

{

  if ( !mMapGrid || !mMap )

  {

    return;

  }


  mMap->beginCommand( tr( "Change Frame Right" ) );

  mMapGrid->setFrameSideFlag( QgsLayoutItemMapGrid::FrameRight, checked );

  mMap->updateBoundingRect();

  mMap->update();

  mMap->endCommand();

}


void QgsLayoutMapGridWidget::mCheckGridTopSide_toggled( bool checked )

{

  if ( !mMapGrid || !mMap )

  {

    return;

  }


  mMap->beginCommand( tr( "Change Frame Top" ) );

  mMapGrid->setFrameSideFlag( QgsLayoutItemMapGrid::FrameTop, checked );

  mMap->updateBoundingRect();

  mMap->update();

  mMap->endCommand();

}


void QgsLayoutMapGridWidget::mCheckGridBottomSide_toggled( bool checked )

{

  if ( !mMapGrid || !mMap )

  {

    return;

  }


  mMap->beginCommand( tr( "Change Frame Bottom" ) );

  mMapGrid->setFrameSideFlag( QgsLayoutItemMapGrid::FrameBottom, checked );

  mMap->updateBoundingRect();

  mMap->update();

  mMap->endCommand();

}


void QgsLayoutMapGridWidget::mFrameDivisionsLeftComboBox_currentIndexChanged( int index )

{

  handleChangedFrameDisplay( QgsLayoutItemMapGrid::Left, static_cast<QgsLayoutItemMapGrid::DisplayMode>( mFrameDivisionsLeftComboBox->itemData( index ).toInt() ) );

}


void QgsLayoutMapGridWidget::mFrameDivisionsRightComboBox_currentIndexChanged( int index )

{

  handleChangedFrameDisplay( QgsLayoutItemMapGrid::Right, static_cast<QgsLayoutItemMapGrid::DisplayMode>( mFrameDivisionsRightComboBox->itemData( index ).toInt() ) );

}


void QgsLayoutMapGridWidget::mFrameDivisionsTopComboBox_currentIndexChanged( int index )

{

  handleChangedFrameDisplay( QgsLayoutItemMapGrid::Top, static_cast<QgsLayoutItemMapGrid::DisplayMode>( mFrameDivisionsTopComboBox->itemData( index ).toInt() ) );

}


void QgsLayoutMapGridWidget::mFrameDivisionsBottomComboBox_currentIndexChanged( int index )

{

  handleChangedFrameDisplay( QgsLayoutItemMapGrid::Bottom, static_cast<QgsLayoutItemMapGrid::DisplayMode>( mFrameDivisionsBottomComboBox->itemData( index ).toInt() ) );

}


void QgsLayoutMapGridWidget::mGridFramePenSizeSpinBox_valueChanged( double d )

{

  if ( !mMapGrid || !mMap )

  {

    return;

  }


  mMap->beginCommand( tr( "Change Frame Thickness" ) );

  mMapGrid->setFramePenSize( d );

  mMap->updateBoundingRect();

  mMap->update();

  mMap->endCommand();

}


void QgsLayoutMapGridWidget::mGridFramePenColorButton_colorChanged( const QColor &newColor )

{

  if ( !mMapGrid || !mMap )

  {

    return;

  }


  mMap->beginCommand( tr( "Change Frame Color" ), QgsLayoutItem::UndoGridFramePenColor );

  mMapGrid->setFramePenColor( newColor );

  mMap->update();

  mMap->endCommand();

}


void QgsLayoutMapGridWidget::mGridFrameFill1ColorButton_colorChanged( const QColor &newColor )

{

  if ( !mMapGrid || !mMap )

  {

    return;

  }


  mMap->beginCommand( tr( "Change Frame Fill Color" ), QgsLayoutItem::UndoMapGridFrameFill1Color );

  mMapGrid->setFrameFillColor1( newColor );

  mMap->update();

  mMap->endCommand();

}


void QgsLayoutMapGridWidget::mGridFrameFill2ColorButton_colorChanged( const QColor &newColor )

{

  if ( !mMapGrid || !mMap )

  {

    return;

  }


  mMap->beginCommand( tr( "Change Frame Fill Color" ), QgsLayoutItem::UndoMapGridFrameFill2Color );

  mMapGrid->setFrameFillColor2( newColor );

  mMap->update();

  mMap->endCommand();

}


void QgsLayoutMapGridWidget::mFrameStyleComboBox_currentIndexChanged( int )

{

  if ( !mMapGrid || !mMap )

  {

    return;

  }


  const QgsLayoutItemMapGrid::FrameStyle style = static_cast<QgsLayoutItemMapGrid::FrameStyle>( mFrameStyleComboBox->currentData().toInt() );

  mMap->beginCommand( tr( "Change Frame Style" ) );

  mMapGrid->setFrameStyle( style );

  switch ( style )

  {

    case QgsLayoutItemMapGrid::Zebra:

    case QgsLayoutItemMapGrid::ZebraNautical:

      toggleFrameControls( true, true, true, false );

      break;

    case QgsLayoutItemMapGrid::InteriorTicks:

    case QgsLayoutItemMapGrid::ExteriorTicks:

    case QgsLayoutItemMapGrid::InteriorExteriorTicks:

      toggleFrameControls( true, false, true, true );

      break;

    case QgsLayoutItemMapGrid::LineBorder:

    case QgsLayoutItemMapGrid::LineBorderNautical:

      toggleFrameControls( true, false, false, false );

      break;

    case QgsLayoutItemMapGrid::NoFrame:

      toggleFrameControls( false, false, false, false );

      break;

  }

  mMap->updateBoundingRect();

  mMap->update();

  mMap->endCommand();

}


void QgsLayoutMapGridWidget::mRotatedTicksGroupBox_toggled( bool state )

{

  if ( !mMapGrid || !mMap )

  {

    return;

  }


  mMap->beginCommand( tr( "Change Tick Rotation Enabled" ) );

  mMapGrid->setRotatedTicksEnabled( state );

  mMap->update();

  mMap->endCommand();

}


void QgsLayoutMapGridWidget::mRotatedTicksLengthModeComboBox_currentIndexChanged( int )

{

  if ( !mMapGrid || !mMap )

  {

    return;

  }


  const QgsLayoutItemMapGrid::TickLengthMode mode = static_cast<QgsLayoutItemMapGrid::TickLengthMode>( mRotatedTicksLengthModeComboBox->currentData().toInt() );

  mMap->beginCommand( tr( "Change Tick Length Mode" ) );

  mMapGrid->setRotatedTicksLengthMode( mode );

  mMap->update();

  mMap->endCommand();

}


void QgsLayoutMapGridWidget::mRotatedTicksThresholdSpinBox_valueChanged( double val )

{

  if ( !mMapGrid || !mMap )

  {

    return;

  }


  mMap->beginCommand( tr( "Change Rotated Ticks Threshold" ) );

  mMapGrid->setRotatedTicksMinimumAngle( val );

  mMap->update();

  mMap->endCommand();

}


void QgsLayoutMapGridWidget::mRotatedTicksMarginToCornerSpinBox_valueChanged( double val )

{

  if ( !mMapGrid || !mMap )

  {

    return;

  }


  mMap->beginCommand( tr( "Change Rotated Ticks Margin to Corner" ) );

  mMapGrid->setRotatedTicksMarginToCorner( val );

  mMap->update();

  mMap->endCommand();

}


void QgsLayoutMapGridWidget::mRotatedAnnotationsGroupBox_toggled( bool state )

{

  if ( !mMapGrid || !mMap )

  {

    return;

  }


  mMap->beginCommand( tr( "Change Annotation Rotation Enabled" ) );

  mMapGrid->setRotatedAnnotationsEnabled( state );

  mMap->update();

  mMap->endCommand();

}


void QgsLayoutMapGridWidget::mRotatedAnnotationsLengthModeComboBox_currentIndexChanged( int )

{

  if ( !mMapGrid || !mMap )

  {

    return;

  }


  const QgsLayoutItemMapGrid::TickLengthMode mode = static_cast<QgsLayoutItemMapGrid::TickLengthMode>( mRotatedAnnotationsLengthModeComboBox->currentData().toInt() );

  mMap->beginCommand( tr( "Change Annotation Length Mode" ) );

  mMapGrid->setRotatedAnnotationsLengthMode( mode );

  mMap->update();

  mMap->endCommand();

}


void QgsLayoutMapGridWidget::mRotatedAnnotationsThresholdSpinBox_valueChanged( double val )

{

  if ( !mMapGrid || !mMap )

  {

    return;

  }


  mMap->beginCommand( tr( "Change Rotated Annotations Threshold" ) );

  mMapGrid->setRotatedAnnotationsMinimumAngle( val );

  mMap->update();

  mMap->endCommand();

}


void QgsLayoutMapGridWidget::mRotatedAnnotationsMarginToCornerSpinBox_valueChanged( double val )

{

  if ( !mMapGrid || !mMap )

  {

    return;

  }


  mMap->beginCommand( tr( "Change Rotated Annotations Margin to Corner" ) );

  mMapGrid->setRotatedAnnotationsMarginToCorner( val );

  mMap->update();

  mMap->endCommand();

}


void QgsLayoutMapGridWidget::intervalUnitChanged( int )

{

  if ( !mMapGrid || !mMap )

  {

    return;

  }


  const QgsLayoutItemMapGrid::GridUnit unit = static_cast<QgsLayoutItemMapGrid::GridUnit>( mMapGridUnitComboBox->currentData().toInt() );

  switch ( unit )

  {

    case QgsLayoutItemMapGrid::MapUnit:

    case QgsLayoutItemMapGrid::MM:

    case QgsLayoutItemMapGrid::CM:

      mIntervalStackedWidget->setCurrentIndex( 0 );

      break;


    case QgsLayoutItemMapGrid::DynamicPageSizeBased:

      mIntervalStackedWidget->setCurrentIndex( 1 );

      break;

  }


  mMap->beginCommand( tr( "Change Grid Unit" ) );

  mMapGrid->setUnits( unit );

  mMap->updateBoundingRect();

  mMap->update();

  mMap->endCommand();

}


void QgsLayoutMapGridWidget::minIntervalChanged( double interval )

{

  mMap->beginCommand( tr( "Change Grid Interval Range" ), QgsLayoutItem::UndoMapGridIntervalRange );

  mMapGrid->setMinimumIntervalWidth( interval );

  mMap->endCommand();

  mMap->updateBoundingRect();

  mMap->update();

}


void QgsLayoutMapGridWidget::maxIntervalChanged( double interval )

{

  mMap->beginCommand( tr( "Change Grid Interval Range" ), QgsLayoutItem::UndoMapGridIntervalRange );

  mMapGrid->setMaximumIntervalWidth( interval );

  mMap->endCommand();

  mMap->updateBoundingRect();

  mMap->update();

}


void QgsLayoutMapGridWidget::annotationTextFormatChanged()

{

  if ( !mMapGrid || !mMap )

  {

    return;

  }


  mMap->beginCommand( tr( "Change Annotation Font" ) );

  mMapGrid->setAnnotationTextFormat( mAnnotationFontButton->textFormat() );

  mMap->endCommand();

  mMap->updateBoundingRect();

  mMap->update();

}


void QgsLayoutMapGridWidget::onCrsChanged()

{

  mBlockAnnotationFormatUpdates++;

  const QgsLayoutItemMapGrid::AnnotationFormat prevFormat = static_cast<QgsLayoutItemMapGrid::AnnotationFormat>( mAnnotationFormatComboBox->currentData().toInt() );


  mAnnotationFormatComboBox->clear();

  mAnnotationFormatComboBox->addItem( tr( "Decimal" ), QgsLayoutItemMapGrid::Decimal );

  mAnnotationFormatComboBox->addItem( tr( "Decimal with Suffix" ), QgsLayoutItemMapGrid::DecimalWithSuffix );


  // only show degree based options for geographic CRSes

  const QgsCoordinateReferenceSystem crs = mMapGrid->crs().isValid() ? mMapGrid->crs() : mMap->crs();

  switch ( crs.mapUnits() )

  {

    case Qgis::DistanceUnit::Meters:

    case Qgis::DistanceUnit::Kilometers:

    case Qgis::DistanceUnit::Feet:

    case Qgis::DistanceUnit::NauticalMiles:

    case Qgis::DistanceUnit::Yards:

    case Qgis::DistanceUnit::Miles:

    case Qgis::DistanceUnit::Centimeters:

    case Qgis::DistanceUnit::Millimeters:

    case Qgis::DistanceUnit::Inches:

    case Qgis::DistanceUnit::ChainsInternational:

    case Qgis::DistanceUnit::ChainsBritishBenoit1895A:

    case Qgis::DistanceUnit::ChainsBritishBenoit1895B:

    case Qgis::DistanceUnit::ChainsBritishSears1922Truncated:

    case Qgis::DistanceUnit::ChainsBritishSears1922:

    case Qgis::DistanceUnit::ChainsClarkes:

    case Qgis::DistanceUnit::ChainsUSSurvey:

    case Qgis::DistanceUnit::FeetBritish1865:

    case Qgis::DistanceUnit::FeetBritish1936:

    case Qgis::DistanceUnit::FeetBritishBenoit1895A:

    case Qgis::DistanceUnit::FeetBritishBenoit1895B:

    case Qgis::DistanceUnit::FeetBritishSears1922Truncated:

    case Qgis::DistanceUnit::FeetBritishSears1922:

    case Qgis::DistanceUnit::FeetClarkes:

    case Qgis::DistanceUnit::FeetGoldCoast:

    case Qgis::DistanceUnit::FeetIndian:

    case Qgis::DistanceUnit::FeetIndian1937:

    case Qgis::DistanceUnit::FeetIndian1962:

    case Qgis::DistanceUnit::FeetIndian1975:

    case Qgis::DistanceUnit::FeetUSSurvey:

    case Qgis::DistanceUnit::LinksInternational:

    case Qgis::DistanceUnit::LinksBritishBenoit1895A:

    case Qgis::DistanceUnit::LinksBritishBenoit1895B:

    case Qgis::DistanceUnit::LinksBritishSears1922Truncated:

    case Qgis::DistanceUnit::LinksBritishSears1922:

    case Qgis::DistanceUnit::LinksClarkes:

    case Qgis::DistanceUnit::LinksUSSurvey:

    case Qgis::DistanceUnit::YardsBritishBenoit1895A:

    case Qgis::DistanceUnit::YardsBritishBenoit1895B:

    case Qgis::DistanceUnit::YardsBritishSears1922Truncated:

    case Qgis::DistanceUnit::YardsBritishSears1922:

    case Qgis::DistanceUnit::YardsClarkes:

    case Qgis::DistanceUnit::YardsIndian:

    case Qgis::DistanceUnit::YardsIndian1937:

    case Qgis::DistanceUnit::YardsIndian1962:

    case Qgis::DistanceUnit::YardsIndian1975:

    case Qgis::DistanceUnit::MilesUSSurvey:

    case Qgis::DistanceUnit::Fathoms:

    case Qgis::DistanceUnit::MetersGermanLegal:

      break;


    case Qgis::DistanceUnit::Degrees:

    case Qgis::DistanceUnit::Unknown:

      mAnnotationFormatComboBox->addItem( tr( "Degree, Minute" ), QgsLayoutItemMapGrid::DegreeMinuteNoSuffix );

      mAnnotationFormatComboBox->addItem( tr( "Degree, Minute with Suffix" ), QgsLayoutItemMapGrid::DegreeMinute );

      mAnnotationFormatComboBox->addItem( tr( "Degree, Minute Aligned" ), QgsLayoutItemMapGrid::DegreeMinutePadded );

      mAnnotationFormatComboBox->addItem( tr( "Degree, Minute, Second" ), QgsLayoutItemMapGrid::DegreeMinuteSecondNoSuffix );

      mAnnotationFormatComboBox->addItem( tr( "Degree, Minute, Second with Suffix" ), QgsLayoutItemMapGrid::DegreeMinuteSecond );

      mAnnotationFormatComboBox->addItem( tr( "Degree, Minute, Second Aligned" ), QgsLayoutItemMapGrid::DegreeMinuteSecondPadded );

      break;

  }

  mAnnotationFormatComboBox->addItem( tr( "Custom" ), QgsLayoutItemMapGrid::CustomFormat );


  const int prevIndex = mAnnotationFormatComboBox->findData( prevFormat );

  if ( prevIndex >= 0 )

    mAnnotationFormatComboBox->setCurrentIndex( prevIndex );

  else

    mAnnotationFormatComboBox->setCurrentIndex( 0 );

  mBlockAnnotationFormatUpdates--;


  const QgsLayoutItemMapGrid::AnnotationFormat newFormat = static_cast<QgsLayoutItemMapGrid::AnnotationFormat>( mAnnotationFormatComboBox->currentData().toInt() );

  if ( newFormat != prevFormat )

  {

    mAnnotationFormatComboBox_currentIndexChanged( mAnnotationFormatComboBox->currentIndex() );

  }

}


void QgsLayoutMapGridWidget::mGridBlendComboBox_currentIndexChanged( int index )

{

  Q_UNUSED( index )

  if ( mMapGrid )

  {

    mMap->beginCommand( tr( "Change Grid Blend Mode" ) );

    mMapGrid->setBlendMode( mGridBlendComboBox->blendMode() );

    mMap->update();

    mMap->endCommand();

  }

}


void QgsLayoutMapGridWidget::mGridTypeComboBox_currentIndexChanged( int )

{

  if ( !mMapGrid || !mMap )

  {

    return;

  }


  mMap->beginCommand( tr( "Change Grid Type" ) );

  switch ( static_cast<QgsLayoutItemMapGrid::GridStyle>( mGridTypeComboBox->currentData().toInt() ) )

  {

    case QgsLayoutItemMapGrid::Cross:

      mMapGrid->setStyle( QgsLayoutItemMapGrid::Cross );

      mCrossWidthSpinBox->setVisible( true );

      mCrossWidthDDBtn->setVisible( true );

      mCrossWidthLabel->setVisible( true );

      mGridLineStyleButton->setVisible( true );

      mLineStyleLabel->setVisible( true );

      mGridMarkerStyleButton->setVisible( false );

      mMarkerStyleFrame->setVisible( false );

      mMarkerStyleFrame->setVisible( false );

      mMarkerStyleLabel->setVisible( false );

      mGridBlendComboBox->setVisible( true );

      mGridBlendLabel->setVisible( true );

      break;


    case QgsLayoutItemMapGrid::Markers:

      mMapGrid->setStyle( QgsLayoutItemMapGrid::Markers );

      mCrossWidthSpinBox->setVisible( false );

      mCrossWidthDDBtn->setVisible( false );

      mCrossWidthLabel->setVisible( false );

      mGridLineStyleButton->setVisible( false );

      mLineStyleLabel->setVisible( false );

      mGridMarkerStyleButton->setVisible( true );

      mMarkerStyleFrame->setVisible( true );

      mMarkerStyleLabel->setVisible( true );

      mGridBlendComboBox->setVisible( true );

      mGridBlendLabel->setVisible( true );

      break;


    case QgsLayoutItemMapGrid::Solid:

      mMapGrid->setStyle( QgsLayoutItemMapGrid::Solid );

      mCrossWidthSpinBox->setVisible( false );

      mCrossWidthDDBtn->setVisible( false );

      mCrossWidthLabel->setVisible( false );

      mGridLineStyleButton->setVisible( true );

      mLineStyleLabel->setVisible( true );

      mGridMarkerStyleButton->setVisible( false );

      mMarkerStyleFrame->setVisible( false );

      mMarkerStyleLabel->setVisible( false );

      mGridBlendComboBox->setVisible( true );

      mGridBlendLabel->setVisible( true );

      break;


    case QgsLayoutItemMapGrid::FrameAnnotationsOnly:

      mMapGrid->setStyle( QgsLayoutItemMapGrid::FrameAnnotationsOnly );

      mCrossWidthSpinBox->setVisible( false );

      mCrossWidthDDBtn->setVisible( false );

      mCrossWidthLabel->setVisible( false );

      mGridLineStyleButton->setVisible( false );

      mLineStyleLabel->setVisible( false );

      mGridMarkerStyleButton->setVisible( false );

      mMarkerStyleFrame->setVisible( false );

      mMarkerStyleLabel->setVisible( false );

      mGridBlendComboBox->setVisible( false );

      mGridBlendLabel->setVisible( false );

      break;

  }


  mMap->updateBoundingRect();

  mMap->update();

  mMap->endCommand();

}


void QgsLayoutMapGridWidget::mapGridCrsChanged( const QgsCoordinateReferenceSystem &crs )

{

  if ( !mMapGrid || !mMap )

  {

    return;

  }


  if ( mMapGrid->crs() == crs )

    return;


  mMap->beginCommand( tr( "Change Grid CRS" ) );

  mMapGrid->setCrs( crs );

  mMap->updateBoundingRect();

  mMap->update();

  mMap->endCommand();

}


void QgsLayoutMapGridWidget::mDrawAnnotationGroupBox_toggled( bool state )

{

  if ( !mMapGrid || !mMap )

  {

    return;

  }


  mMap->beginCommand( tr( "Toggle Annotations" ) );

  mMapGrid->setAnnotationEnabled( state );

  mMap->updateBoundingRect();

  mMap->update();

  mMap->endCommand();

}


void QgsLayoutMapGridWidget::mAnnotationFormatButton_clicked()

{

  if ( !mMapGrid || !mMap )

  {

    return;

  }


  QgsExpressionContext expressionContext = mMapGrid->createExpressionContext();

  expressionContext.setHighlightedFunctions( QStringList() << QStringLiteral( "to_dms" ) << QStringLiteral( "to_dm" ) );


  QgsExpressionBuilderDialog exprDlg( coverageLayer(), mMapGrid->annotationExpression(), this, QStringLiteral( "generic" ), expressionContext );

  exprDlg.setWindowTitle( tr( "Expression Based Annotation" ) );


  if ( exprDlg.exec() == QDialog::Accepted )

  {

    const QString expression = exprDlg.expressionText();

    mMap->beginCommand( tr( "Change Annotation Format" ) );

    mMapGrid->setAnnotationExpression( expression );

    mMap->updateBoundingRect();

    mMap->update();

    mMap->endCommand();

  }

}


void QgsLayoutMapGridWidget::mAnnotationDisplayLeftComboBox_currentIndexChanged( int )

{

  handleChangedAnnotationDisplay( QgsLayoutItemMapGrid::Left, static_cast<QgsLayoutItemMapGrid::DisplayMode>( mAnnotationDisplayLeftComboBox->currentData().toInt() ) );

}


void QgsLayoutMapGridWidget::mAnnotationDisplayRightComboBox_currentIndexChanged( int )

{

  handleChangedAnnotationDisplay( QgsLayoutItemMapGrid::Right, static_cast<QgsLayoutItemMapGrid::DisplayMode>( mAnnotationDisplayRightComboBox->currentData().toInt() ) );

}


void QgsLayoutMapGridWidget::mAnnotationDisplayTopComboBox_currentIndexChanged( int )

{

  handleChangedAnnotationDisplay( QgsLayoutItemMapGrid::Top, static_cast<QgsLayoutItemMapGrid::DisplayMode>( mAnnotationDisplayTopComboBox->currentData().toInt() ) );

}


void QgsLayoutMapGridWidget::mAnnotationDisplayBottomComboBox_currentIndexChanged( int )

{

  handleChangedAnnotationDisplay( QgsLayoutItemMapGrid::Bottom, static_cast<QgsLayoutItemMapGrid::DisplayMode>( mAnnotationDisplayBottomComboBox->currentData().toInt() ) );

}


void QgsLayoutMapGridWidget::mAnnotationPositionLeftComboBox_currentIndexChanged( int )

{

  handleChangedAnnotationPosition( QgsLayoutItemMapGrid::Left, static_cast<QgsLayoutItemMapGrid::AnnotationPosition>( mAnnotationPositionLeftComboBox->currentData().toInt() ) );

}


void QgsLayoutMapGridWidget::mAnnotationPositionRightComboBox_currentIndexChanged( int )

{

  handleChangedAnnotationPosition( QgsLayoutItemMapGrid::Right, static_cast<QgsLayoutItemMapGrid::AnnotationPosition>( mAnnotationPositionRightComboBox->currentData().toInt() ) );

}


void QgsLayoutMapGridWidget::mAnnotationPositionTopComboBox_currentIndexChanged( int )

{

  handleChangedAnnotationPosition( QgsLayoutItemMapGrid::Top, static_cast<QgsLayoutItemMapGrid::AnnotationPosition>( mAnnotationPositionTopComboBox->currentData().toInt() ) );

}


void QgsLayoutMapGridWidget::mAnnotationPositionBottomComboBox_currentIndexChanged( int )

{

  handleChangedAnnotationPosition( QgsLayoutItemMapGrid::Bottom, static_cast<QgsLayoutItemMapGrid::AnnotationPosition>( mAnnotationPositionBottomComboBox->currentData().toInt() ) );

}


void QgsLayoutMapGridWidget::mAnnotationDirectionComboBoxLeft_currentIndexChanged( int index )

{

  handleChangedAnnotationDirection( QgsLayoutItemMapGrid::Left, static_cast<QgsLayoutItemMapGrid::AnnotationDirection>( mAnnotationDirectionComboBoxLeft->itemData( index ).toInt() ) );

}


void QgsLayoutMapGridWidget::mAnnotationDirectionComboBoxRight_currentIndexChanged( int index )

{

  handleChangedAnnotationDirection( QgsLayoutItemMapGrid::Right, static_cast<QgsLayoutItemMapGrid::AnnotationDirection>( mAnnotationDirectionComboBoxRight->itemData( index ).toInt() ) );

}


void QgsLayoutMapGridWidget::mAnnotationDirectionComboBoxTop_currentIndexChanged( int index )

{

  handleChangedAnnotationDirection( QgsLayoutItemMapGrid::Top, static_cast<QgsLayoutItemMapGrid::AnnotationDirection>( mAnnotationDirectionComboBoxTop->itemData( index ).toInt() ) );

}


void QgsLayoutMapGridWidget::mAnnotationDirectionComboBoxBottom_currentIndexChanged( int index )

{

  handleChangedAnnotationDirection( QgsLayoutItemMapGrid::Bottom, static_cast<QgsLayoutItemMapGrid::AnnotationDirection>( mAnnotationDirectionComboBoxBottom->itemData( index ).toInt() ) );

}


void QgsLayoutMapGridWidget::mDistanceToMapFrameSpinBox_valueChanged( double d )

{

  if ( !mMapGrid || !mMap )

  {

    return;

  }


  mMap->beginCommand( tr( "Change Annotation Distance" ), QgsLayoutItem::UndoMapAnnotationDistance );

  mMapGrid->setAnnotationFrameDistance( d );

  mMap->updateBoundingRect();

  mMap->update();

  mMap->endCommand();

}


void QgsLayoutMapGridWidget::lineSymbolChanged()

{

  if ( !mMapGrid || !mMap )

  {

    return;

  }


  mMap->beginCommand( tr( "Change Grid Line Style" ), QgsLayoutItem::UndoMapGridLineSymbol );

  mMapGrid->setLineSymbol( mGridLineStyleButton->clonedSymbol<QgsLineSymbol>() );

  mMap->endCommand();

  mMap->update();

}


void QgsLayoutMapGridWidget::markerSymbolChanged()

{

  if ( !mMapGrid || !mMap )

  {

    return;

  }


  mMap->beginCommand( tr( "Change Grid Marker Style" ), QgsLayoutItem::UndoMapGridMarkerSymbol );

  mMapGrid->setMarkerSymbol( mGridMarkerStyleButton->clonedSymbol<QgsMarkerSymbol>() );

  mMap->endCommand();

  mMap->update();

}


void QgsLayoutMapGridWidget::gridEnabledToggled( bool active )

{

  if ( !mMapGrid || !mMap )

  {

    return;

  }


  mMap->beginCommand( tr( "Toggle Grid Display" ) );

  mMapGrid->setEnabled( active );

  mMap->endCommand();

  mMap->updateBoundingRect();

  mMap->update();

}


void QgsLayoutMapGridWidget::mAnnotationFormatComboBox_currentIndexChanged( int index )

{

  if ( !mMapGrid || !mMap )

  {

    return;

  }

  if ( mBlockAnnotationFormatUpdates )

    return;


  mMap->beginCommand( tr( "Change Annotation Format" ) );


  mMapGrid->setAnnotationFormat( static_cast<QgsLayoutItemMapGrid::AnnotationFormat>( mAnnotationFormatComboBox->itemData( index ).toInt() ) );

  mAnnotationFormatButton->setEnabled( mMapGrid->annotationFormat() == QgsLayoutItemMapGrid::CustomFormat );


  mMap->updateBoundingRect();

  mMap->update();

  mMap->endCommand();

}


void QgsLayoutMapGridWidget::mCoordinatePrecisionSpinBox_valueChanged( int value )

{

  if ( !mMapGrid || !mMap )

  {

    return;

  }

  mMap->beginCommand( tr( "Change Annotation Precision" ) );

  mMapGrid->setAnnotationPrecision( value );

  mMap->updateBoundingRect();

  mMap->update();

  mMap->endCommand();

}

Qgis::DistanceUnit::YardsBritishSears1922Truncated
@ YardsBritishSears1922Truncated
British yards (Sears 1922 truncated).
Definition qgis.h:5053

Qgis::DistanceUnit::Feet
@ Feet
Imperial feet.
Definition qgis.h:5016

Qgis::DistanceUnit::MilesUSSurvey
@ MilesUSSurvey
US Survey miles.
Definition qgis.h:5060

Qgis::DistanceUnit::LinksBritishSears1922
@ LinksBritishSears1922
British links (Sears 1922).
Definition qgis.h:5048

Qgis::DistanceUnit::YardsBritishBenoit1895A
@ YardsBritishBenoit1895A
British yards (Benoit 1895 A).
Definition qgis.h:5051

Qgis::DistanceUnit::LinksBritishBenoit1895A
@ LinksBritishBenoit1895A
British links (Benoit 1895 A).
Definition qgis.h:5045

Qgis::DistanceUnit::Centimeters
@ Centimeters
Centimeters.
Definition qgis.h:5021

Qgis::DistanceUnit::YardsIndian1975
@ YardsIndian1975
Indian yards (1975).
Definition qgis.h:5059

Qgis::DistanceUnit::FeetUSSurvey
@ FeetUSSurvey
US Survey feet.
Definition qgis.h:5043

Qgis::DistanceUnit::Millimeters
@ Millimeters
Millimeters.
Definition qgis.h:5022

Qgis::DistanceUnit::FeetBritishSears1922
@ FeetBritishSears1922
British feet (Sears 1922).
Definition qgis.h:5036

Qgis::DistanceUnit::YardsClarkes
@ YardsClarkes
Clarke's yards.
Definition qgis.h:5055

Qgis::DistanceUnit::YardsIndian
@ YardsIndian
Indian yards.
Definition qgis.h:5056

Qgis::DistanceUnit::FeetBritishBenoit1895B
@ FeetBritishBenoit1895B
British feet (Benoit 1895 B).
Definition qgis.h:5034

Qgis::DistanceUnit::Miles
@ Miles
Terrestrial miles.
Definition qgis.h:5019

Qgis::DistanceUnit::LinksUSSurvey
@ LinksUSSurvey
US Survey links.
Definition qgis.h:5050

Qgis::DistanceUnit::Meters
@ Meters
Meters.
Definition qgis.h:5014

Qgis::DistanceUnit::ChainsUSSurvey
@ ChainsUSSurvey
US Survey chains.
Definition qgis.h:5030

Qgis::DistanceUnit::FeetClarkes
@ FeetClarkes
Clarke's feet.
Definition qgis.h:5037

Qgis::DistanceUnit::Unknown
@ Unknown
Unknown distance unit.
Definition qgis.h:5063

Qgis::DistanceUnit::Yards
@ Yards
Imperial yards.
Definition qgis.h:5018

Qgis::DistanceUnit::FeetBritish1936
@ FeetBritish1936
British feet (1936).
Definition qgis.h:5032

Qgis::DistanceUnit::FeetIndian1962
@ FeetIndian1962
Indian feet (1962).
Definition qgis.h:5041

Qgis::DistanceUnit::YardsBritishSears1922
@ YardsBritishSears1922
British yards (Sears 1922).
Definition qgis.h:5054

Qgis::DistanceUnit::FeetIndian1937
@ FeetIndian1937
Indian feet (1937).
Definition qgis.h:5040

Qgis::DistanceUnit::YardsIndian1937
@ YardsIndian1937
Indian yards (1937).
Definition qgis.h:5057

Qgis::DistanceUnit::Degrees
@ Degrees
Degrees, for planar geographic CRS distance measurements.
Definition qgis.h:5020

Qgis::DistanceUnit::ChainsBritishBenoit1895B
@ ChainsBritishBenoit1895B
British chains (Benoit 1895 B).
Definition qgis.h:5026

Qgis::DistanceUnit::LinksBritishSears1922Truncated
@ LinksBritishSears1922Truncated
British links (Sears 1922 truncated).
Definition qgis.h:5047

Qgis::DistanceUnit::ChainsBritishBenoit1895A
@ ChainsBritishBenoit1895A
British chains (Benoit 1895 A).
Definition qgis.h:5025

Qgis::DistanceUnit::YardsBritishBenoit1895B
@ YardsBritishBenoit1895B
British yards (Benoit 1895 B).
Definition qgis.h:5052

Qgis::DistanceUnit::FeetBritish1865
@ FeetBritish1865
British feet (1865).
Definition qgis.h:5031

Qgis::DistanceUnit::YardsIndian1962
@ YardsIndian1962
Indian yards (1962).
Definition qgis.h:5058

Qgis::DistanceUnit::FeetBritishSears1922Truncated
@ FeetBritishSears1922Truncated
British feet (Sears 1922 truncated).
Definition qgis.h:5035

Qgis::DistanceUnit::MetersGermanLegal
@ MetersGermanLegal
German legal meter.
Definition qgis.h:5062

Qgis::DistanceUnit::LinksBritishBenoit1895B
@ LinksBritishBenoit1895B
British links (Benoit 1895 B).
Definition qgis.h:5046

Qgis::DistanceUnit::ChainsInternational
@ ChainsInternational
International chains.
Definition qgis.h:5024

Qgis::DistanceUnit::Inches
@ Inches
Inches.
Definition qgis.h:5023

Qgis::DistanceUnit::Fathoms
@ Fathoms
Fathoms.
Definition qgis.h:5061

Qgis::DistanceUnit::LinksInternational
@ LinksInternational
International links.
Definition qgis.h:5044

Qgis::DistanceUnit::ChainsBritishSears1922Truncated
@ ChainsBritishSears1922Truncated
British chains (Sears 1922 truncated).
Definition qgis.h:5027

Qgis::DistanceUnit::FeetIndian
@ FeetIndian
Indian (geodetic) feet.
Definition qgis.h:5039

Qgis::DistanceUnit::NauticalMiles
@ NauticalMiles
Nautical miles.
Definition qgis.h:5017

Qgis::DistanceUnit::ChainsClarkes
@ ChainsClarkes
Clarke's chains.
Definition qgis.h:5029

Qgis::DistanceUnit::LinksClarkes
@ LinksClarkes
Clarke's links.
Definition qgis.h:5049

Qgis::DistanceUnit::ChainsBritishSears1922
@ ChainsBritishSears1922
British chains (Sears 1922).
Definition qgis.h:5028

Qgis::DistanceUnit::Kilometers
@ Kilometers
Kilometers.
Definition qgis.h:5015

Qgis::DistanceUnit::FeetIndian1975
@ FeetIndian1975
Indian feet (1975).
Definition qgis.h:5042

Qgis::DistanceUnit::FeetGoldCoast
@ FeetGoldCoast
Gold Coast feet.
Definition qgis.h:5038

Qgis::DistanceUnit::FeetBritishBenoit1895A
@ FeetBritishBenoit1895A
British feet (Benoit 1895 A).
Definition qgis.h:5033

Qgis::SymbolType::Marker
@ Marker
Marker symbol.
Definition qgis.h:611

Qgis::SymbolType::Line
@ Line
Line symbol.
Definition qgis.h:612

QgsColorButton::colorChanged
void colorChanged(const QColor &color)
Emitted whenever a new color is set for the button.

QgsCoordinateReferenceSystem
Represents a coordinate reference system (CRS).
Definition qgscoordinatereferencesystem.h:212

QgsCoordinateReferenceSystem::mapUnits
Qgis::DistanceUnit mapUnits
Definition qgscoordinatereferencesystem.h:215

QgsExpressionContext::setHighlightedFunctions
void setHighlightedFunctions(const QStringList &names)
Sets the list of function names intended to be highlighted to the user.
Definition qgsexpressioncontext.cpp:474

QgsFontButton::ModeTextRenderer
@ ModeTextRenderer
Configure font settings for use with QgsTextRenderer.
Definition qgsfontbutton.h:60

QgsFontButton::setLayer
void setLayer(QgsVectorLayer *layer)
Sets a layer to associate with the widget.
Definition qgsfontbutton.cpp:764

QgsFontButton::changed
void changed()
Emitted when the widget's text format settings are changed.

QgsLayoutItemBaseWidget::updateDataDefinedButton
void updateDataDefinedButton(QgsPropertyOverrideButton *button)
Updates a previously registered data defined button to reflect the item's current properties.
Definition qgslayoutitemwidget.cpp:253

QgsLayoutItemBaseWidget::coverageLayer
QgsVectorLayer * coverageLayer() const
Returns the current layout context coverage layer (if set).
Definition qgslayoutitemwidget.cpp:258

QgsLayoutItemBaseWidget::registerDataDefinedButton
void registerDataDefinedButton(QgsPropertyOverrideButton *button, QgsLayoutObject::DataDefinedProperty property)
Registers a data defined button, setting up its initial value, connections and description.
Definition qgslayoutitemwidget.cpp:248

QgsLayoutItemBaseWidget::QgsLayoutItemBaseWidget
QgsLayoutItemBaseWidget(QWidget *parent SIP_TRANSFERTHIS, QgsLayoutObject *layoutObject)
Constructor for QgsLayoutItemBaseWidget, linked with the specified layoutObject.
Definition qgslayoutitemwidget.cpp:192

QgsLayoutItemMapGrid
An individual grid which is drawn above the map content in a QgsLayoutItemMap.
Definition qgslayoutitemmapgrid.h:140

QgsLayoutItemMapGrid::GridStyle
GridStyle
Grid drawing style.
Definition qgslayoutitemmapgrid.h:161

QgsLayoutItemMapGrid::Markers
@ Markers
Draw markers at intersections of grid lines.
Definition qgslayoutitemmapgrid.h:164

QgsLayoutItemMapGrid::Cross
@ Cross
Draw line crosses at intersections of grid lines.
Definition qgslayoutitemmapgrid.h:163

QgsLayoutItemMapGrid::FrameAnnotationsOnly
@ FrameAnnotationsOnly
No grid lines over the map, only draw frame and annotations.
Definition qgslayoutitemmapgrid.h:165

QgsLayoutItemMapGrid::Solid
@ Solid
Definition qgslayoutitemmapgrid.h:162

QgsLayoutItemMapGrid::GridUnit
GridUnit
Unit for grid values.
Definition qgslayoutitemmapgrid.h:150

QgsLayoutItemMapGrid::CM
@ CM
Grid units in centimeters.
Definition qgslayoutitemmapgrid.h:153

QgsLayoutItemMapGrid::MM
@ MM
Grid units in millimeters.
Definition qgslayoutitemmapgrid.h:152

QgsLayoutItemMapGrid::DynamicPageSizeBased
@ DynamicPageSizeBased
Dynamically sized, based on a on-page size range.
Definition qgslayoutitemmapgrid.h:154

QgsLayoutItemMapGrid::MapUnit
@ MapUnit
Grid units follow map units.
Definition qgslayoutitemmapgrid.h:151

QgsLayoutItemMapGrid::FrameTop
@ FrameTop
Top side of map.
Definition qgslayoutitemmapgrid.h:260

QgsLayoutItemMapGrid::FrameBottom
@ FrameBottom
Bottom side of map.
Definition qgslayoutitemmapgrid.h:261

QgsLayoutItemMapGrid::FrameLeft
@ FrameLeft
Left side of map.
Definition qgslayoutitemmapgrid.h:258

QgsLayoutItemMapGrid::FrameRight
@ FrameRight
Right side of map.
Definition qgslayoutitemmapgrid.h:259

QgsLayoutItemMapGrid::AnnotationPosition
AnnotationPosition
Position for grid annotations.
Definition qgslayoutitemmapgrid.h:183

QgsLayoutItemMapGrid::InsideMapFrame
@ InsideMapFrame
Draw annotations inside the map frame.
Definition qgslayoutitemmapgrid.h:184

QgsLayoutItemMapGrid::OutsideMapFrame
@ OutsideMapFrame
Draw annotations outside the map frame.
Definition qgslayoutitemmapgrid.h:185

QgsLayoutItemMapGrid::DisplayMode
DisplayMode
Display settings for grid annotations and frames.
Definition qgslayoutitemmapgrid.h:172

QgsLayoutItemMapGrid::LongitudeOnly
@ LongitudeOnly
Show longitude/x annotations/divisions only.
Definition qgslayoutitemmapgrid.h:175

QgsLayoutItemMapGrid::ShowAll
@ ShowAll
Show both latitude and longitude annotations/divisions.
Definition qgslayoutitemmapgrid.h:173

QgsLayoutItemMapGrid::HideAll
@ HideAll
No annotations.
Definition qgslayoutitemmapgrid.h:176

QgsLayoutItemMapGrid::LatitudeOnly
@ LatitudeOnly
Show latitude/y annotations/divisions only.
Definition qgslayoutitemmapgrid.h:174

QgsLayoutItemMapGrid::crsChanged
void crsChanged()
Emitted whenever the grid's CRS is changed.

QgsLayoutItemMapGrid::TickLengthMode
TickLengthMode
Tick length mode (useful for rotated grids).
Definition qgslayoutitemmapgrid.h:248

QgsLayoutItemMapGrid::OrthogonalTicks
@ OrthogonalTicks
Align ticks orthogonaly.
Definition qgslayoutitemmapgrid.h:249

QgsLayoutItemMapGrid::NormalizedTicks
@ NormalizedTicks
Constant tick lengths.
Definition qgslayoutitemmapgrid.h:250

QgsLayoutItemMapGrid::AnnotationFormat
AnnotationFormat
Format for displaying grid annotations.
Definition qgslayoutitemmapgrid.h:206

QgsLayoutItemMapGrid::DegreeMinuteSecondNoSuffix
@ DegreeMinuteSecondNoSuffix
Degree/minutes/seconds, use - for S/W coordinates.
Definition qgslayoutitemmapgrid.h:213

QgsLayoutItemMapGrid::DegreeMinuteSecondPadded
@ DegreeMinuteSecondPadded
Degree/minutes/seconds, with minutes using leading zeros where required.
Definition qgslayoutitemmapgrid.h:214

QgsLayoutItemMapGrid::DegreeMinuteSecond
@ DegreeMinuteSecond
Degree/minutes/seconds, use NSEW suffix.
Definition qgslayoutitemmapgrid.h:209

QgsLayoutItemMapGrid::DecimalWithSuffix
@ DecimalWithSuffix
Decimal degrees, use NSEW suffix.
Definition qgslayoutitemmapgrid.h:210

QgsLayoutItemMapGrid::DegreeMinute
@ DegreeMinute
Degree/minutes, use NSEW suffix.
Definition qgslayoutitemmapgrid.h:208

QgsLayoutItemMapGrid::DegreeMinuteNoSuffix
@ DegreeMinuteNoSuffix
Degree/minutes, use - for S/W coordinates.
Definition qgslayoutitemmapgrid.h:211

QgsLayoutItemMapGrid::Decimal
@ Decimal
Decimal degrees, use - for S/W coordinates.
Definition qgslayoutitemmapgrid.h:207

QgsLayoutItemMapGrid::DegreeMinutePadded
@ DegreeMinutePadded
Degree/minutes, with minutes using leading zeros where required.
Definition qgslayoutitemmapgrid.h:212

QgsLayoutItemMapGrid::CustomFormat
@ CustomFormat
Custom expression-based format.
Definition qgslayoutitemmapgrid.h:215

QgsLayoutItemMapGrid::AnnotationDirection
AnnotationDirection
Direction of grid annotations.
Definition qgslayoutitemmapgrid.h:192

QgsLayoutItemMapGrid::OnTick
@ OnTick
Draw annotations parallel to tick (on the line).
Definition qgslayoutitemmapgrid.h:198

QgsLayoutItemMapGrid::Horizontal
@ Horizontal
Draw annotations horizontally.
Definition qgslayoutitemmapgrid.h:193

QgsLayoutItemMapGrid::Vertical
@ Vertical
Draw annotations vertically, ascending.
Definition qgslayoutitemmapgrid.h:194

QgsLayoutItemMapGrid::BoundaryDirection
@ BoundaryDirection
Annotations follow the boundary direction.
Definition qgslayoutitemmapgrid.h:196

QgsLayoutItemMapGrid::AboveTick
@ AboveTick
Draw annotations parallel to tick (above the line).
Definition qgslayoutitemmapgrid.h:197

QgsLayoutItemMapGrid::UnderTick
@ UnderTick
Draw annotations parallel to tick (under the line).
Definition qgslayoutitemmapgrid.h:199

QgsLayoutItemMapGrid::VerticalDescending
@ VerticalDescending
Draw annotations vertically, descending.
Definition qgslayoutitemmapgrid.h:195

QgsLayoutItemMapGrid::FrameStyle
FrameStyle
Style for grid frame.
Definition qgslayoutitemmapgrid.h:233

QgsLayoutItemMapGrid::Zebra
@ Zebra
Black/white pattern.
Definition qgslayoutitemmapgrid.h:235

QgsLayoutItemMapGrid::InteriorTicks
@ InteriorTicks
Tick markers drawn inside map frame.
Definition qgslayoutitemmapgrid.h:236

QgsLayoutItemMapGrid::LineBorder
@ LineBorder
Simple solid line frame.
Definition qgslayoutitemmapgrid.h:239

QgsLayoutItemMapGrid::InteriorExteriorTicks
@ InteriorExteriorTicks
Tick markers drawn both inside and outside the map frame.
Definition qgslayoutitemmapgrid.h:238

QgsLayoutItemMapGrid::LineBorderNautical
@ LineBorderNautical
Simple solid line frame, with nautical style diagonals on corners.
Definition qgslayoutitemmapgrid.h:240

QgsLayoutItemMapGrid::ExteriorTicks
@ ExteriorTicks
Tick markers drawn outside map frame.
Definition qgslayoutitemmapgrid.h:237

QgsLayoutItemMapGrid::NoFrame
@ NoFrame
Disable grid frame.
Definition qgslayoutitemmapgrid.h:234

QgsLayoutItemMapGrid::ZebraNautical
@ ZebraNautical
Black/white pattern, with nautical style diagonals on corners.
Definition qgslayoutitemmapgrid.h:241

QgsLayoutItemMapGrid::BorderSide
BorderSide
Border sides for annotations.
Definition qgslayoutitemmapgrid.h:222

QgsLayoutItemMapGrid::Bottom
@ Bottom
Bottom border.
Definition qgslayoutitemmapgrid.h:225

QgsLayoutItemMapGrid::Left
@ Left
Left border.
Definition qgslayoutitemmapgrid.h:223

QgsLayoutItemMapGrid::Right
@ Right
Right border.
Definition qgslayoutitemmapgrid.h:224

QgsLayoutItemMapGrid::Top
@ Top
Top border.
Definition qgslayoutitemmapgrid.h:226

QgsLayoutItemMap
Layout graphical items for displaying a map.
Definition qgslayoutitemmap.h:336

QgsLayoutItem::UndoGridFramePenColor
@ UndoGridFramePenColor
Map grid frame pen color.
Definition qgslayoutitem.h:246

QgsLayoutItem::UndoMapGridIntervalRange
@ UndoMapGridIntervalRange
Grid interval range.
Definition qgslayoutitem.h:253

QgsLayoutItem::UndoMapGridLineSymbol
@ UndoMapGridLineSymbol
Grid line symbol.
Definition qgslayoutitem.h:251

QgsLayoutItem::UndoMapGridMarkerSymbol
@ UndoMapGridMarkerSymbol
Grid marker symbol.
Definition qgslayoutitem.h:252

QgsLayoutItem::UndoMapGridFrameFill1Color
@ UndoMapGridFrameFill1Color
Map grid frame fill color 1.
Definition qgslayoutitem.h:247

QgsLayoutItem::UndoMapAnnotationDistance
@ UndoMapAnnotationDistance
Map frame annotation distance.
Definition qgslayoutitem.h:249

QgsLayoutItem::UndoMapGridFrameFill2Color
@ UndoMapGridFrameFill2Color
Map grid frame fill color 2.
Definition qgslayoutitem.h:248

QgsLayoutMapGridWidget::populateDataDefinedButtons
void populateDataDefinedButtons()
Initializes data defined buttons to current atlas coverage layer.
Definition qgslayoutmapgridwidget.cpp:227

QgsLayoutMapGridWidget::updateGuiElements
virtual void updateGuiElements()
Sets the current composer map values to the GUI elements.
Definition qgslayoutmapgridwidget.cpp:254

QgsLayoutMapGridWidget::QgsLayoutMapGridWidget
QgsLayoutMapGridWidget(QgsLayoutItemMapGrid *mapGrid, QgsLayoutItemMap *map)
constructor
Definition qgslayoutmapgridwidget.cpp:34

QgsLayoutObject::DataDefinedProperty::MapGridOffsetY
@ MapGridOffsetY
Map grid offset Y.
Definition qgslayoutobject.h:190

QgsLayoutObject::DataDefinedProperty::MapGridFrameDivisionsBottom
@ MapGridFrameDivisionsBottom
Map frame division display bottom.
Definition qgslayoutobject.h:203

QgsLayoutObject::DataDefinedProperty::MapGridEnabled
@ MapGridEnabled
Map grid enabled.
Definition qgslayoutobject.h:186

QgsLayoutObject::DataDefinedProperty::MapGridIntervalX
@ MapGridIntervalX
Map grid interval X.
Definition qgslayoutobject.h:187

QgsLayoutObject::DataDefinedProperty::MapGridFrameDivisionsTop
@ MapGridFrameDivisionsTop
Map frame division display top.
Definition qgslayoutobject.h:202

QgsLayoutObject::DataDefinedProperty::MapGridAnnotationDisplayLeft
@ MapGridAnnotationDisplayLeft
Map annotation display left.
Definition qgslayoutobject.h:196

QgsLayoutObject::DataDefinedProperty::MapGridFrameMargin
@ MapGridFrameMargin
Map grid frame margin.
Definition qgslayoutobject.h:192

QgsLayoutObject::DataDefinedProperty::MapGridDrawAnnotation
@ MapGridDrawAnnotation
Map annotation visibility (for individual annotations).
Definition qgslayoutobject.h:204

QgsLayoutObject::DataDefinedProperty::MapGridCrossSize
@ MapGridCrossSize
Map grid cross size.
Definition qgslayoutobject.h:194

QgsLayoutObject::DataDefinedProperty::MapGridAnnotationDisplayRight
@ MapGridAnnotationDisplayRight
Map annotation display right.
Definition qgslayoutobject.h:197

QgsLayoutObject::DataDefinedProperty::MapGridOffsetX
@ MapGridOffsetX
Map grid offset X.
Definition qgslayoutobject.h:189

QgsLayoutObject::DataDefinedProperty::MapGridAnnotationDisplayTop
@ MapGridAnnotationDisplayTop
Map annotation display top.
Definition qgslayoutobject.h:198

QgsLayoutObject::DataDefinedProperty::MapGridAnnotationDisplayBottom
@ MapGridAnnotationDisplayBottom
Map annotation display bottom.
Definition qgslayoutobject.h:199

QgsLayoutObject::DataDefinedProperty::MapGridFrameDivisionsRight
@ MapGridFrameDivisionsRight
Map frame division display right.
Definition qgslayoutobject.h:201

QgsLayoutObject::DataDefinedProperty::MapGridLabelDistance
@ MapGridLabelDistance
Map grid label distance.
Definition qgslayoutobject.h:193

QgsLayoutObject::DataDefinedProperty::MapGridIntervalY
@ MapGridIntervalY
Map grid interval Y.
Definition qgslayoutobject.h:188

QgsLayoutObject::DataDefinedProperty::MapGridFrameSize
@ MapGridFrameSize
Map grid frame size.
Definition qgslayoutobject.h:191

QgsLayoutObject::DataDefinedProperty::MapGridFrameLineThickness
@ MapGridFrameLineThickness
Map grid frame line thickness.
Definition qgslayoutobject.h:195

QgsLayoutObject::DataDefinedProperty::MapGridFrameDivisionsLeft
@ MapGridFrameDivisionsLeft
Map frame division display left.
Definition qgslayoutobject.h:200

QgsLayoutReportContext::layerChanged
void layerChanged(QgsVectorLayer *layer)
Emitted when the context's layer is changed.

QgsPanelWidget::setPanelTitle
void setPanelTitle(const QString &panelTitle)
Set the title of the panel when shown in the interface.
Definition qgspanelwidget.h:44

QgsProjectViewSettings::mapScales
QVector< double > mapScales() const
Returns the list of custom project map scales.
Definition qgsprojectviewsettings.cpp:139

QgsProject::instance
static QgsProject * instance()
Returns the QgsProject singleton instance.
Definition qgsproject.cpp:471

QgsProject::viewSettings
const QgsProjectViewSettings * viewSettings() const
Returns the project's view settings, which contains settings and properties relating to how a QgsProj...
Definition qgsproject.cpp:4394

QgsProjectionSelectionWidget::CrsNotSet
@ CrsNotSet
Not set (hidden by default).
Definition qgsprojectionselectionwidget.h:60

QgsProjectionSelectionWidget::crsChanged
void crsChanged(const QgsCoordinateReferenceSystem &crs)
Emitted when the selected CRS is changed.

QgsSettingsEntryBaseTemplate::value
T value(const QString &dynamicKeyPart=QString()) const
Returns settings value.
Definition qgssettingsentry.h:429

QgsSettingsRegistryCore::settingsMapScales
static const QgsSettingsEntryStringList * settingsMapScales
Definition qgssettingsregistrycore.h:160

QgsSymbolButton::setLayer
void setLayer(QgsVectorLayer *layer)
Sets a layer to associate with the widget.
Definition qgssymbolbutton.cpp:235

QgsSymbolButton::changed
void changed()
Emitted when the symbol's settings are changed.

c
As part of the API refactoring and improvements which landed in the Processing API was substantially reworked from the x version This was done in order to allow much of the underlying Processing framework to be ported into c
Definition porting_processing.dox:1

whileBlocking
QgsSignalBlocker< Object > whileBlocking(Object *object)
Temporarily blocks signals from a QObject while calling a single method from the object.
Definition qgis.h:6511

qgsexpressionbuilderdialog.h

qgslayout.h

qgslayoutitemmap.h

qgslayoutmapgridwidget.h

qgslayoutreportcontext.h

qgslinesymbol.h

qgsmarkersymbol.h

qgsproject.h

qgsprojectviewsettings.h

qgssettingsregistrycore.h

qgssymbol.h

qgsvectorlayer.h