api/master/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 "qgstextrenderer.h"

#include "qgsvectorlayer.h"


#include <QString>


#include "moc_qgslayoutmapgridwidget.cpp"


using namespace Qt::StringLiterals;


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

  : QgsLayoutItemBaseWidget( nullptr, mapGrid )

  , mMap( map )

  , mMapGrid( mapGrid )

{

  setupUi( this );


  mFrameStyleComboBox->addItem( tr( "No Frame" ), QVariant::fromValue( Qgis::MapGridFrameStyle::NoFrame ) );

  mFrameStyleComboBox->addItem( tr( "Zebra" ), QVariant::fromValue( Qgis::MapGridFrameStyle::Zebra ) );

  mFrameStyleComboBox->addItem( tr( "Zebra (Nautical)" ), QVariant::fromValue( Qgis::MapGridFrameStyle::ZebraNautical ) );

  mFrameStyleComboBox->addItem( tr( "Interior Ticks" ), QVariant::fromValue( Qgis::MapGridFrameStyle::InteriorTicks ) );

  mFrameStyleComboBox->addItem( tr( "Exterior Ticks" ), QVariant::fromValue( Qgis::MapGridFrameStyle::ExteriorTicks ) );

  mFrameStyleComboBox->addItem( tr( "Interior and Exterior Ticks" ), QVariant::fromValue( Qgis::MapGridFrameStyle::InteriorExteriorTicks ) );

  mFrameStyleComboBox->addItem( tr( "Line Border" ), QVariant::fromValue( Qgis::MapGridFrameStyle::LineBorder ) );

  mFrameStyleComboBox->addItem( tr( "Line Border (Nautical)" ), QVariant::fromValue( Qgis::MapGridFrameStyle::LineBorderNautical ) );


  mRotatedTicksLengthModeComboBox->addItem( tr( "Orthogonal" ), QVariant::fromValue( Qgis::MapGridTickLengthMode::OrthogonalTicks ) );

  mRotatedTicksLengthModeComboBox->addItem( tr( "Fixed Length" ), QVariant::fromValue( Qgis::MapGridTickLengthMode::NormalizedTicks ) );

  mRotatedAnnotationsLengthModeComboBox->addItem( tr( "Orthogonal" ), QVariant::fromValue( Qgis::MapGridTickLengthMode::OrthogonalTicks ) );

  mRotatedAnnotationsLengthModeComboBox->addItem( tr( "Fixed Length" ), QVariant::fromValue( Qgis::MapGridTickLengthMode::NormalizedTicks ) );


  mHAlignmentComboBox->setAvailableAlignments( Qt::AlignmentFlag::AlignLeft | Qt::AlignmentFlag::AlignHCenter | Qt::AlignmentFlag::AlignRight | Qt::AlignmentFlag::AlignJustify );


  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( mHAlignmentComboBox, &QgsAlignmentComboBox::changed, this, [this] {

    mMap->beginCommand( tr( "Change Grid Text Alignment" ) );

    mMapGrid->setHorizontalAlignment( mHAlignmentComboBox->horizontalAlignment() );

    mMap->endCommand();

    mMap->updateBoundingRect();

    mMap->update();

  } );


  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" ), QVariant::fromValue( Qgis::MapGridUnit::MapUnits ) );

  mMapGridUnitComboBox->addItem( tr( "Fit Segment Width" ), QVariant::fromValue( Qgis::MapGridUnit::DynamicPageSizeBased ) );

  mMapGridUnitComboBox->addItem( tr( "Millimeters" ), QVariant::fromValue( Qgis::MapGridUnit::Millimeters ) );

  mMapGridUnitComboBox->addItem( tr( "Centimeters" ), QVariant::fromValue( Qgis::MapGridUnit::Centimeters ) );


  mGridTypeComboBox->insertItem( 0, tr( "Solid" ), QVariant::fromValue( Qgis::MapGridStyle::Lines ) );

  mGridTypeComboBox->insertItem( 1, tr( "Cross" ), QVariant::fromValue( Qgis::MapGridStyle::LineCrosses ) );

  mGridTypeComboBox->insertItem( 2, tr( "Markers" ), QVariant::fromValue( Qgis::MapGridStyle::Markers ) );

  mGridTypeComboBox->insertItem( 3, tr( "Frame and annotations only" ), QVariant::fromValue( Qgis::MapGridStyle::FrameAndAnnotationsOnly ) );


  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( u"composer"_s );

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

  mGridFramePenColorButton->setShowNoColor( true );


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

  mGridFrameFill1ColorButton->setAllowOpacity( true );

  mGridFrameFill1ColorButton->setContext( u"composer"_s );

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

  mGridFrameFill1ColorButton->setShowNoColor( true );


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

  mGridFrameFill2ColorButton->setAllowOpacity( true );

  mGridFrameFill2ColorButton->setContext( u"composer"_s );

  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 );

  mHAlignmentComboBox->blockSignals( block );

}


void QgsLayoutMapGridWidget::handleChangedFrameDisplay( Qgis::MapGridBorderSide border, const Qgis::MapGridComponentVisibility mode )

{

  if ( !mMapGrid || !mMap )

  {

    return;

  }


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

  mMapGrid->setFrameDivisions( mode, border );

  mMap->endCommand();

  mMap->updateBoundingRect();

}


void QgsLayoutMapGridWidget::handleChangedAnnotationDisplay( Qgis::MapGridBorderSide border, const Qgis::MapGridComponentVisibility 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" ), QVariant::fromValue( Qgis::MapGridAnnotationPosition::InsideMapFrame ) );

  c->insertItem( 1, tr( "Outside Frame" ), QVariant::fromValue( Qgis::MapGridAnnotationPosition::OutsideMapFrame ) );

}


void QgsLayoutMapGridWidget::insertAnnotationDirectionEntries( QComboBox *c )

{

  c->addItem( tr( "Horizontal" ), QVariant::fromValue( Qgis::MapGridAnnotationDirection::Horizontal ) );

  c->addItem( tr( "Vertical Ascending" ), QVariant::fromValue( Qgis::MapGridAnnotationDirection::Vertical ) );

  c->addItem( tr( "Vertical Descending" ), QVariant::fromValue( Qgis::MapGridAnnotationDirection::VerticalDescending ) );

  c->addItem( tr( "Boundary Direction" ), QVariant::fromValue( Qgis::MapGridAnnotationDirection::BoundaryDirection ) );

  // c->addItem( tr( "Parallel to Tick" ), QVariant::fromValue( Qgis::MapGridAnnotationDirection::ParallelToTick ) );

  c->addItem( tr( "Above Tick" ), QVariant::fromValue( Qgis::MapGridAnnotationDirection::AboveTick ) );

  c->addItem( tr( "On Tick" ), QVariant::fromValue( Qgis::MapGridAnnotationDirection::OnTick ) );

  c->addItem( tr( "Under Tick" ), QVariant::fromValue( Qgis::MapGridAnnotationDirection::UnderTick ) );

}


void QgsLayoutMapGridWidget::initFrameDisplayBox( QComboBox *c, Qgis::MapGridComponentVisibility display )

{

  if ( !c )

  {

    return;

  }

  c->setCurrentIndex( c->findData( QVariant::fromValue( display ) ) );

}


void QgsLayoutMapGridWidget::handleChangedAnnotationPosition( Qgis::MapGridBorderSide border, const Qgis::MapGridAnnotationPosition position )

{

  if ( !mMapGrid || !mMap )

  {

    return;

  }


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

  mMapGrid->setAnnotationPosition( position, border );


  mMap->updateBoundingRect();

  mMap->update();

  mMap->endCommand();

}


void QgsLayoutMapGridWidget::handleChangedAnnotationDirection( Qgis::MapGridBorderSide border, Qgis::MapGridAnnotationDirection 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" ), QVariant::fromValue( Qgis::MapGridComponentVisibility::ShowAll ) );

  c->addItem( tr( "Latitude/Y Only" ), QVariant::fromValue( Qgis::MapGridComponentVisibility::LatitudeOnly ) );

  c->addItem( tr( "Longitude/X Only" ), QVariant::fromValue( Qgis::MapGridComponentVisibility::LongitudeOnly ) );

}


void QgsLayoutMapGridWidget::insertAnnotationDisplayEntries( QComboBox *c )

{

  c->insertItem( 0, tr( "Show All" ), QVariant::fromValue( Qgis::MapGridComponentVisibility::ShowAll ) );

  c->insertItem( 1, tr( "Show Latitude/Y Only" ), QVariant::fromValue( Qgis::MapGridComponentVisibility::LatitudeOnly ) );

  c->insertItem( 2, tr( "Show Longitude/X Only" ), QVariant::fromValue( Qgis::MapGridComponentVisibility::LongitudeOnly ) );

  c->insertItem( 3, tr( "Disabled" ), QVariant::fromValue( Qgis::MapGridComponentVisibility::HideAll ) );

}


void QgsLayoutMapGridWidget::initAnnotationPositionBox( QComboBox *c, Qgis::MapGridAnnotationPosition pos )

{

  if ( !c )

  {

    return;

  }


  c->setCurrentIndex( c->findData( QVariant::fromValue( pos ) ) );

}


void QgsLayoutMapGridWidget::initAnnotationDirectionBox( QComboBox *c, Qgis::MapGridAnnotationDirection dir )

{

  if ( !c )

  {

    return;

  }

  c->setCurrentIndex( c->findData( QVariant::fromValue( 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 Qgis::MapGridStyle gridStyle = mMapGrid->style();

  mGridTypeComboBox->setCurrentIndex( mGridTypeComboBox->findData( QVariant::fromValue( gridStyle ) ) );

  switch ( gridStyle )

  {

    case Qgis::MapGridStyle::LineCrosses:

      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 Qgis::MapGridStyle::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 Qgis::MapGridStyle::Lines:

      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 Qgis::MapGridStyle::FrameAndAnnotationsOnly:

      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 Qgis::MapGridFrameStyle gridFrameStyle = mMapGrid->frameStyle();

  mFrameStyleComboBox->setCurrentIndex( mFrameStyleComboBox->findData( QVariant::fromValue( gridFrameStyle ) ) );

  switch ( gridFrameStyle )

  {

    case Qgis::MapGridFrameStyle::Zebra:

    case Qgis::MapGridFrameStyle::ZebraNautical:

      toggleFrameControls( true, true, true, false );

      break;

    case Qgis::MapGridFrameStyle::InteriorTicks:

    case Qgis::MapGridFrameStyle::ExteriorTicks:

    case Qgis::MapGridFrameStyle::InteriorExteriorTicks:

      toggleFrameControls( true, false, true, true );

      break;

    case Qgis::MapGridFrameStyle::LineBorder:

    case Qgis::MapGridFrameStyle::LineBorderNautical:

      toggleFrameControls( true, false, false, false );

      break;

    case Qgis::MapGridFrameStyle::NoFrame:

      toggleFrameControls( false, false, false, false );

      break;

  }


  mCheckGridLeftSide->setChecked( mMapGrid->testFrameSideFlag( Qgis::MapGridFrameSideFlag::Left ) );

  mCheckGridRightSide->setChecked( mMapGrid->testFrameSideFlag( Qgis::MapGridFrameSideFlag::Right ) );

  mCheckGridTopSide->setChecked( mMapGrid->testFrameSideFlag( Qgis::MapGridFrameSideFlag::Top ) );

  mCheckGridBottomSide->setChecked( mMapGrid->testFrameSideFlag( Qgis::MapGridFrameSideFlag::Bottom ) );


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

  mRotatedTicksLengthModeComboBox->setCurrentIndex( mRotatedTicksLengthModeComboBox->findData( QVariant::fromValue( mMapGrid->rotatedTicksLengthMode() ) ) );

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

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


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

  mRotatedAnnotationsLengthModeComboBox->setCurrentIndex( mRotatedAnnotationsLengthModeComboBox->findData( QVariant::fromValue( mMapGrid->rotatedAnnotationsLengthMode() ) ) );

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

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


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

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

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

  initFrameDisplayBox( mFrameDivisionsBottomComboBox, mMapGrid->frameDivisions( Qgis::MapGridBorderSide::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( QVariant::fromValue( mMapGrid->annotationDisplay( Qgis::MapGridBorderSide::Left ) ) ) );

  mAnnotationDisplayRightComboBox->setCurrentIndex( mAnnotationDisplayRightComboBox->findData( QVariant::fromValue( mMapGrid->annotationDisplay( Qgis::MapGridBorderSide::Right ) ) ) );

  mAnnotationDisplayTopComboBox->setCurrentIndex( mAnnotationDisplayTopComboBox->findData( QVariant::fromValue( mMapGrid->annotationDisplay( Qgis::MapGridBorderSide::Top ) ) ) );

  mAnnotationDisplayBottomComboBox->setCurrentIndex( mAnnotationDisplayBottomComboBox->findData( QVariant::fromValue( mMapGrid->annotationDisplay( Qgis::MapGridBorderSide::Bottom ) ) ) );


  mAnnotationPositionLeftComboBox->setCurrentIndex( mAnnotationPositionLeftComboBox->findData( QVariant::fromValue( mMapGrid->annotationPosition( Qgis::MapGridBorderSide::Left ) ) ) );

  mAnnotationPositionRightComboBox->setCurrentIndex( mAnnotationPositionRightComboBox->findData( QVariant::fromValue( mMapGrid->annotationPosition( Qgis::MapGridBorderSide::Right ) ) ) );

  mAnnotationPositionTopComboBox->setCurrentIndex( mAnnotationPositionTopComboBox->findData( QVariant::fromValue( mMapGrid->annotationPosition( Qgis::MapGridBorderSide::Top ) ) ) );

  mAnnotationPositionBottomComboBox->setCurrentIndex( mAnnotationPositionBottomComboBox->findData( QVariant::fromValue( mMapGrid->annotationPosition( Qgis::MapGridBorderSide::Bottom ) ) ) );


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

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

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

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


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

  mAnnotationFontButton->setMode( QgsFontButton::ModeTextRenderer );

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


  mAnnotationFormatComboBox->setCurrentIndex( mAnnotationFormatComboBox->findData( QVariant::fromValue( mMapGrid->annotationFormat() ) ) );

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

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

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


  mHAlignmentComboBox->setCurrentAlignment( mMapGrid->horizontalAlignment() );


  //Unit

  mMapGridUnitComboBox->setCurrentIndex( mMapGridUnitComboBox->findData( QVariant::fromValue( mMapGrid->units() ) ) );

  switch ( mMapGrid->units() )

  {

    case Qgis::MapGridUnit::MapUnits:

    case Qgis::MapGridUnit::Millimeters:

    case Qgis::MapGridUnit::Centimeters:

      mIntervalStackedWidget->setCurrentIndex( 0 );

      break;


    case Qgis::MapGridUnit::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( Qgis::MapGridFrameSideFlag::Left, 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( Qgis::MapGridFrameSideFlag::Right, 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( Qgis::MapGridFrameSideFlag::Top, 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( Qgis::MapGridFrameSideFlag::Bottom, checked );

  mMap->updateBoundingRect();

  mMap->update();

  mMap->endCommand();

}


void QgsLayoutMapGridWidget::mFrameDivisionsLeftComboBox_currentIndexChanged( int index )

{

  handleChangedFrameDisplay( Qgis::MapGridBorderSide::Left, mFrameDivisionsLeftComboBox->itemData( index ).value< Qgis::MapGridComponentVisibility >() );

}


void QgsLayoutMapGridWidget::mFrameDivisionsRightComboBox_currentIndexChanged( int index )

{

  handleChangedFrameDisplay( Qgis::MapGridBorderSide::Right, mFrameDivisionsRightComboBox->itemData( index ).value< Qgis::MapGridComponentVisibility >() );

}


void QgsLayoutMapGridWidget::mFrameDivisionsTopComboBox_currentIndexChanged( int index )

{

  handleChangedFrameDisplay( Qgis::MapGridBorderSide::Top, mFrameDivisionsTopComboBox->itemData( index ).value< Qgis::MapGridComponentVisibility >() );

}


void QgsLayoutMapGridWidget::mFrameDivisionsBottomComboBox_currentIndexChanged( int index )

{

  handleChangedFrameDisplay( Qgis::MapGridBorderSide::Bottom, mFrameDivisionsBottomComboBox->itemData( index ).value< Qgis::MapGridComponentVisibility >() );

}


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 Qgis::MapGridFrameStyle style = mFrameStyleComboBox->currentData().value< Qgis::MapGridFrameStyle >();

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

  mMapGrid->setFrameStyle( style );

  switch ( style )

  {

    case Qgis::MapGridFrameStyle::Zebra:

    case Qgis::MapGridFrameStyle::ZebraNautical:

      toggleFrameControls( true, true, true, false );

      break;

    case Qgis::MapGridFrameStyle::InteriorTicks:

    case Qgis::MapGridFrameStyle::ExteriorTicks:

    case Qgis::MapGridFrameStyle::InteriorExteriorTicks:

      toggleFrameControls( true, false, true, true );

      break;

    case Qgis::MapGridFrameStyle::LineBorder:

    case Qgis::MapGridFrameStyle::LineBorderNautical:

      toggleFrameControls( true, false, false, false );

      break;

    case Qgis::MapGridFrameStyle::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 Qgis::MapGridTickLengthMode mode = mRotatedTicksLengthModeComboBox->currentData().value< Qgis::MapGridTickLengthMode >();

  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 Qgis::MapGridTickLengthMode mode = mRotatedAnnotationsLengthModeComboBox->currentData().value< Qgis::MapGridTickLengthMode >();

  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 Qgis::MapGridUnit unit = mMapGridUnitComboBox->currentData().value< Qgis::MapGridUnit >();

  switch ( unit )

  {

    case Qgis::MapGridUnit::MapUnits:

    case Qgis::MapGridUnit::Millimeters:

    case Qgis::MapGridUnit::Centimeters:

      mIntervalStackedWidget->setCurrentIndex( 0 );

      break;


    case Qgis::MapGridUnit::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 Qgis::MapGridAnnotationFormat prevFormat = mAnnotationFormatComboBox->currentData().value< Qgis::MapGridAnnotationFormat >();


  mAnnotationFormatComboBox->clear();

  mAnnotationFormatComboBox->addItem( tr( "Decimal" ), QVariant::fromValue( Qgis::MapGridAnnotationFormat::Decimal ) );

  mAnnotationFormatComboBox->addItem( tr( "Decimal with Suffix" ), QVariant::fromValue( Qgis::MapGridAnnotationFormat::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" ), QVariant::fromValue( Qgis::MapGridAnnotationFormat::DegreeMinuteNoSuffix ) );

      mAnnotationFormatComboBox->addItem( tr( "Degree, Minute with Suffix" ), QVariant::fromValue( Qgis::MapGridAnnotationFormat::DegreeMinute ) );

      mAnnotationFormatComboBox->addItem( tr( "Degree, Minute Aligned" ), QVariant::fromValue( Qgis::MapGridAnnotationFormat::DegreeMinutePadded ) );

      mAnnotationFormatComboBox->addItem( tr( "Degree, Minute, Second" ), QVariant::fromValue( Qgis::MapGridAnnotationFormat::DegreeMinuteSecondNoSuffix ) );

      mAnnotationFormatComboBox->addItem( tr( "Degree, Minute, Second with Suffix" ), QVariant::fromValue( Qgis::MapGridAnnotationFormat::DegreeMinuteSecond ) );

      mAnnotationFormatComboBox->addItem( tr( "Degree, Minute, Second Aligned" ), QVariant::fromValue( Qgis::MapGridAnnotationFormat::DegreeMinuteSecondPadded ) );

      break;

  }

  mAnnotationFormatComboBox->addItem( tr( "Custom" ), QVariant::fromValue( Qgis::MapGridAnnotationFormat::CustomFormat ) );


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

  if ( prevIndex >= 0 )

    mAnnotationFormatComboBox->setCurrentIndex( prevIndex );

  else

    mAnnotationFormatComboBox->setCurrentIndex( 0 );

  mBlockAnnotationFormatUpdates--;


  const Qgis::MapGridAnnotationFormat newFormat = mAnnotationFormatComboBox->currentData().value< Qgis::MapGridAnnotationFormat >();

  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 ( mGridTypeComboBox->currentData().value< Qgis::MapGridStyle >() )

  {

    case Qgis::MapGridStyle::LineCrosses:

      mMapGrid->setStyle( Qgis::MapGridStyle::LineCrosses );

      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 Qgis::MapGridStyle::Markers:

      mMapGrid->setStyle( Qgis::MapGridStyle::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 Qgis::MapGridStyle::Lines:

      mMapGrid->setStyle( Qgis::MapGridStyle::Lines );

      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 Qgis::MapGridStyle::FrameAndAnnotationsOnly:

      mMapGrid->setStyle( Qgis::MapGridStyle::FrameAndAnnotationsOnly );

      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() << u"to_dms"_s << u"to_dm"_s );


  QgsExpressionBuilderDialog exprDlg( coverageLayer(), mMapGrid->annotationExpression(), this, u"generic"_s, 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( Qgis::MapGridBorderSide::Left, mAnnotationDisplayLeftComboBox->currentData().value< Qgis::MapGridComponentVisibility >() );

}


void QgsLayoutMapGridWidget::mAnnotationDisplayRightComboBox_currentIndexChanged( int )

{

  handleChangedAnnotationDisplay( Qgis::MapGridBorderSide::Right, mAnnotationDisplayRightComboBox->currentData().value< Qgis::MapGridComponentVisibility >() );

}


void QgsLayoutMapGridWidget::mAnnotationDisplayTopComboBox_currentIndexChanged( int )

{

  handleChangedAnnotationDisplay( Qgis::MapGridBorderSide::Top, mAnnotationDisplayTopComboBox->currentData().value< Qgis::MapGridComponentVisibility >() );

}


void QgsLayoutMapGridWidget::mAnnotationDisplayBottomComboBox_currentIndexChanged( int )

{

  handleChangedAnnotationDisplay( Qgis::MapGridBorderSide::Bottom, mAnnotationDisplayBottomComboBox->currentData().value< Qgis::MapGridComponentVisibility >() );

}


void QgsLayoutMapGridWidget::mAnnotationPositionLeftComboBox_currentIndexChanged( int )

{

  handleChangedAnnotationPosition( Qgis::MapGridBorderSide::Left, mAnnotationPositionLeftComboBox->currentData().value< Qgis::MapGridAnnotationPosition >() );

}


void QgsLayoutMapGridWidget::mAnnotationPositionRightComboBox_currentIndexChanged( int )

{

  handleChangedAnnotationPosition( Qgis::MapGridBorderSide::Right, mAnnotationPositionRightComboBox->currentData().value< Qgis::MapGridAnnotationPosition >() );

}


void QgsLayoutMapGridWidget::mAnnotationPositionTopComboBox_currentIndexChanged( int )

{

  handleChangedAnnotationPosition( Qgis::MapGridBorderSide::Top, mAnnotationPositionTopComboBox->currentData().value< Qgis::MapGridAnnotationPosition >() );

}


void QgsLayoutMapGridWidget::mAnnotationPositionBottomComboBox_currentIndexChanged( int )

{

  handleChangedAnnotationPosition( Qgis::MapGridBorderSide::Bottom, mAnnotationPositionBottomComboBox->currentData().value< Qgis::MapGridAnnotationPosition >() );

}


void QgsLayoutMapGridWidget::mAnnotationDirectionComboBoxLeft_currentIndexChanged( int index )

{

  handleChangedAnnotationDirection( Qgis::MapGridBorderSide::Left, mAnnotationDirectionComboBoxLeft->itemData( index ).value< Qgis::MapGridAnnotationDirection >() );

}


void QgsLayoutMapGridWidget::mAnnotationDirectionComboBoxRight_currentIndexChanged( int index )

{

  handleChangedAnnotationDirection( Qgis::MapGridBorderSide::Right, mAnnotationDirectionComboBoxRight->itemData( index ).value< Qgis::MapGridAnnotationDirection >() );

}


void QgsLayoutMapGridWidget::mAnnotationDirectionComboBoxTop_currentIndexChanged( int index )

{

  handleChangedAnnotationDirection( Qgis::MapGridBorderSide::Top, mAnnotationDirectionComboBoxTop->itemData( index ).value< Qgis::MapGridAnnotationDirection >() );

}


void QgsLayoutMapGridWidget::mAnnotationDirectionComboBoxBottom_currentIndexChanged( int index )

{

  handleChangedAnnotationDirection( Qgis::MapGridBorderSide::Bottom, mAnnotationDirectionComboBoxBottom->itemData( index ).value< Qgis::MapGridAnnotationDirection >() );

}


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( mAnnotationFormatComboBox->itemData( index ).value< Qgis::MapGridAnnotationFormat >() );

  mAnnotationFormatButton->setEnabled( mMapGrid->annotationFormat() == Qgis::MapGridAnnotationFormat::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::MapGridTickLengthMode
MapGridTickLengthMode
Map grid tick length mode (useful for rotated grids).
Definition qgis.h:5620

Qgis::MapGridTickLengthMode::OrthogonalTicks
@ OrthogonalTicks
Align ticks orthogonaly.
Definition qgis.h:5621

Qgis::MapGridTickLengthMode::NormalizedTicks
@ NormalizedTicks
Constant tick lengths.
Definition qgis.h:5622

Qgis::MapGridAnnotationPosition
MapGridAnnotationPosition
Position for map grid annotations.
Definition qgis.h:5530

Qgis::MapGridAnnotationPosition::InsideMapFrame
@ InsideMapFrame
Draw annotations inside the map frame.
Definition qgis.h:5531

Qgis::MapGridAnnotationPosition::OutsideMapFrame
@ OutsideMapFrame
Draw annotations outside the map frame.
Definition qgis.h:5532

Qgis::MapGridUnit
MapGridUnit
Units for map grid values.
Definition qgis.h:5482

Qgis::MapGridUnit::Centimeters
@ Centimeters
Grid units in centimeters.
Definition qgis.h:5485

Qgis::MapGridUnit::Millimeters
@ Millimeters
Grid units in millimeters.
Definition qgis.h:5484

Qgis::MapGridUnit::DynamicPageSizeBased
@ DynamicPageSizeBased
Dynamically sized, based on a on-page size range.
Definition qgis.h:5486

Qgis::MapGridUnit::MapUnits
@ MapUnits
Grid units follow map units.
Definition qgis.h:5483

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Qgis::MapGridBorderSide
MapGridBorderSide
Border sides for map grid annotations.
Definition qgis.h:5584

Qgis::MapGridBorderSide::Bottom
@ Bottom
Bottom border.
Definition qgis.h:5587

Qgis::MapGridBorderSide::Right
@ Right
Right border.
Definition qgis.h:5586

Qgis::MapGridBorderSide::Left
@ Left
Left border.
Definition qgis.h:5585

Qgis::MapGridBorderSide::Top
@ Top
Top border.
Definition qgis.h:5588

Qgis::MapGridFrameSideFlag::Bottom
@ Bottom
Bottom side of map.
Definition qgis.h:5639

Qgis::MapGridFrameSideFlag::Right
@ Right
Right side of map.
Definition qgis.h:5637

Qgis::MapGridFrameSideFlag::Left
@ Left
Left side of map.
Definition qgis.h:5636

Qgis::MapGridFrameSideFlag::Top
@ Top
Top side of map.
Definition qgis.h:5638

Qgis::MapGridComponentVisibility
MapGridComponentVisibility
Visibility display settings for map grid annotations and frames.
Definition qgis.h:5514

Qgis::MapGridComponentVisibility::ShowAll
@ ShowAll
Show both latitude and longitude annotations/divisions.
Definition qgis.h:5515

Qgis::MapGridComponentVisibility::LongitudeOnly
@ LongitudeOnly
Show longitude/x annotations/divisions only.
Definition qgis.h:5517

Qgis::MapGridComponentVisibility::LatitudeOnly
@ LatitudeOnly
Show latitude/y annotations/divisions only.
Definition qgis.h:5516

Qgis::MapGridComponentVisibility::HideAll
@ HideAll
No annotations.
Definition qgis.h:5518

Qgis::MapGridStyle
MapGridStyle
Map grid drawing styles.
Definition qgis.h:5498

Qgis::MapGridStyle::LineCrosses
@ LineCrosses
Draw line crosses at intersections of grid lines.
Definition qgis.h:5500

Qgis::MapGridStyle::Markers
@ Markers
Draw markers at intersections of grid lines.
Definition qgis.h:5501

Qgis::MapGridStyle::Lines
@ Lines
Draw lines for grid.
Definition qgis.h:5499

Qgis::MapGridStyle::FrameAndAnnotationsOnly
@ FrameAndAnnotationsOnly
No grid lines over the map, only draw frame and annotations.
Definition qgis.h:5502

Qgis::MapGridFrameStyle
MapGridFrameStyle
Style for map grid frames.
Definition qgis.h:5600

Qgis::MapGridFrameStyle::LineBorderNautical
@ LineBorderNautical
Simple solid line frame, with nautical style diagonals on corners.
Definition qgis.h:5607

Qgis::MapGridFrameStyle::ZebraNautical
@ ZebraNautical
Black/white pattern, with nautical style diagonals on corners.
Definition qgis.h:5608

Qgis::MapGridFrameStyle::InteriorExteriorTicks
@ InteriorExteriorTicks
Tick markers drawn both inside and outside the map frame.
Definition qgis.h:5605

Qgis::MapGridFrameStyle::NoFrame
@ NoFrame
Disable grid frame.
Definition qgis.h:5601

Qgis::MapGridFrameStyle::ExteriorTicks
@ ExteriorTicks
Tick markers drawn outside map frame.
Definition qgis.h:5604

Qgis::MapGridFrameStyle::Zebra
@ Zebra
Black/white pattern.
Definition qgis.h:5602

Qgis::MapGridFrameStyle::LineBorder
@ LineBorder
Simple solid line frame.
Definition qgis.h:5606

Qgis::MapGridFrameStyle::InteriorTicks
@ InteriorTicks
Tick markers drawn inside map frame.
Definition qgis.h:5603

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

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

Qgis::MapGridAnnotationDirection
MapGridAnnotationDirection
Direction of grid annotations.
Definition qgis.h:5544

Qgis::MapGridAnnotationDirection::Vertical
@ Vertical
Draw annotations vertically, ascending.
Definition qgis.h:5546

Qgis::MapGridAnnotationDirection::UnderTick
@ UnderTick
Draw annotations parallel to tick (under the line).
Definition qgis.h:5551

Qgis::MapGridAnnotationDirection::VerticalDescending
@ VerticalDescending
Draw annotations vertically, descending.
Definition qgis.h:5547

Qgis::MapGridAnnotationDirection::BoundaryDirection
@ BoundaryDirection
Annotations follow the boundary direction.
Definition qgis.h:5548

Qgis::MapGridAnnotationDirection::AboveTick
@ AboveTick
Draw annotations parallel to tick (above the line).
Definition qgis.h:5549

Qgis::MapGridAnnotationDirection::OnTick
@ OnTick
Draw annotations parallel to tick (on the line).
Definition qgis.h:5550

Qgis::MapGridAnnotationDirection::Horizontal
@ Horizontal
Draw annotations horizontally.
Definition qgis.h:5545

Qgis::MapGridAnnotationFormat
MapGridAnnotationFormat
Format for displaying map grid annotations.
Definition qgis.h:5563

Qgis::MapGridAnnotationFormat::DegreeMinute
@ DegreeMinute
Degree/minutes, use NSEW suffix.
Definition qgis.h:5565

Qgis::MapGridAnnotationFormat::DegreeMinuteSecond
@ DegreeMinuteSecond
Degree/minutes/seconds, use NSEW suffix.
Definition qgis.h:5566

Qgis::MapGridAnnotationFormat::DegreeMinuteNoSuffix
@ DegreeMinuteNoSuffix
Degree/minutes, use - for S/W coordinates.
Definition qgis.h:5568

Qgis::MapGridAnnotationFormat::CustomFormat
@ CustomFormat
Custom expression-based format.
Definition qgis.h:5572

Qgis::MapGridAnnotationFormat::Decimal
@ Decimal
Decimal degrees, use - for S/W coordinates.
Definition qgis.h:5564

Qgis::MapGridAnnotationFormat::DegreeMinuteSecondNoSuffix
@ DegreeMinuteSecondNoSuffix
Degree/minutes/seconds, use - for S/W coordinates.
Definition qgis.h:5570

Qgis::MapGridAnnotationFormat::DegreeMinutePadded
@ DegreeMinutePadded
Degree/minutes, with minutes using leading zeros where required.
Definition qgis.h:5569

Qgis::MapGridAnnotationFormat::DegreeMinuteSecondPadded
@ DegreeMinuteSecondPadded
Degree/minutes/seconds, with minutes using leading zeros where required.
Definition qgis.h:5571

Qgis::MapGridAnnotationFormat::DecimalWithSuffix
@ DecimalWithSuffix
Decimal degrees, use NSEW suffix.
Definition qgis.h:5567

QgsAlignmentComboBox::changed
void changed()
Emitted when the alignment is changed.

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:216

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

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:767

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:256

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

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:251

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

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

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

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:243

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

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

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:142

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

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:4452

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:431

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

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

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:6854

qgsexpressionbuilderdialog.h

qgslayout.h

qgslayoutitemmap.h

qgslayoutmapgridwidget.h

qgslayoutreportcontext.h

qgslinesymbol.h

qgsmarkersymbol.h

qgsproject.h

qgsprojectviewsettings.h

qgssettingsregistrycore.h

qgssymbol.h

qgstextrenderer.h

qgsvectorlayer.h