qgslayoutitemmapgrid.h

Go to the documentation of this file.

/***************************************************************************
                         qgslayoutitemmapgrid.h
                         ----------------------
    begin                : October 2017
    copyright            : (C) 2017 by Marco Hugentobler, Nyall Dawson
    email                : marco dot hugentobler at sourcepole dot ch
 ***************************************************************************/
 
/***************************************************************************
 *                                                                         *
 *   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.                                   *
 *                                                                         *
 ***************************************************************************/
 
#ifndef QGSLAYOUTITEMMAPGRID_H
#define QGSLAYOUTITEMMAPGRID_H
 
#include "qgis_core.h"
#include "qgis_sip.h"
#include "qgslayoutitemmapitem.h"
#include "qgstextformat.h"
 
#include <QPainter>
#include <QVector2D>
 
class QgsCoordinateTransform;
class QgsLayoutItemMapGrid;
class QgsLayoutItemMap;
class QDomDocument;
class QDomElement;
class QPainter;
class QgsRenderContext;
class QgsLineSymbol;

class CORE_EXPORT QgsLayoutItemMapGridStack : public QgsLayoutItemMapItemStack
{
  public:
    QgsLayoutItemMapGridStack( QgsLayoutItemMap *map );

    void addGrid( QgsLayoutItemMapGrid *grid SIP_TRANSFER );

    void removeGrid( const QString &gridId );

    void moveGridUp( const QString &gridId );

    void moveGridDown( const QString &gridId );

    QgsLayoutItemMapGrid *grid( const QString &gridId ) const;

    QgsLayoutItemMapGrid *grid( int index ) const;

    QgsLayoutItemMapGrid &operator[]( int index ); // cppcheck-suppress duplInheritedMember

    QList< QgsLayoutItemMapGrid * > asList() const; // cppcheck-suppress duplInheritedMember
 
    bool readXml( const QDomElement &elem, const QDomDocument &doc, const QgsReadWriteContext &context ) override;

    double maxGridExtension() const;

    void calculateMaxGridExtension( double &top, double &right, double &bottom, double &left ) const;
};
 
//
// QgsLayoutItemMapGrid
//

class CORE_EXPORT QgsLayoutItemMapGrid : public QgsLayoutItemMapItem
{
    Q_OBJECT
 
  public:
    QgsLayoutItemMapGrid( const QString &name, QgsLayoutItemMap *map );
    ~QgsLayoutItemMapGrid() override;
 
    void draw( QPainter *painter ) override;
    bool writeXml( QDomElement &elem, QDomDocument &doc, const QgsReadWriteContext &context ) const override;
    bool readXml( const QDomElement &itemElem, const QDomDocument &doc, const QgsReadWriteContext &context ) override;

    void setCrs( const QgsCoordinateReferenceSystem &crs );

    QgsCoordinateReferenceSystem crs() const { return mCRS; }

    void setBlendMode( const QPainter::CompositionMode mode ) { mBlendMode = mode; }

    QPainter::CompositionMode blendMode() const { return mBlendMode; }
 
    bool usesAdvancedEffects() const override;

    double maxExtension() const;

    void calculateMaxExtension( double &top, double &right, double &bottom, double &left ) const;
 
    void setEnabled( bool enabled ) override;
 
    //
    // GRID UNITS
    //

    void setUnits( Qgis::MapGridUnit unit );

    Qgis::MapGridUnit units() const { return mGridUnit; }

    void setIntervalX( double interval );

    double intervalX() const { return mGridIntervalX; }

    void setIntervalY( double interval );

    double intervalY() const { return mGridIntervalY; }

    void setOffsetX( double offset );

    double offsetX() const { return mGridOffsetX; }

    void setOffsetY( double offset );

    double offsetY() const { return mGridOffsetY; }

    double minimumIntervalWidth() const { return mMinimumIntervalWidth; }

    void setMinimumIntervalWidth( double width );

    double maximumIntervalWidth() const { return mMaximumIntervalWidth; }

    void setMaximumIntervalWidth( double width );
 
    //
    // GRID APPEARANCE
    //

    void setStyle( Qgis::MapGridStyle style );

    Qgis::MapGridStyle style() const { return mGridStyle; }

    void setCrossLength( const double length );

    double crossLength() const { return mCrossLength; }

    void setGridLineWidth( double width );

    void setGridLineColor( const QColor &color );

    void setLineSymbol( QgsLineSymbol *symbol SIP_TRANSFER );

    const QgsLineSymbol *lineSymbol() const SIP_SKIP;

    QgsLineSymbol *lineSymbol();

    void setMarkerSymbol( QgsMarkerSymbol *symbol SIP_TRANSFER );

    const QgsMarkerSymbol *markerSymbol() const SIP_SKIP;

    QgsMarkerSymbol *markerSymbol();
 
    //
    // ANNOTATIONS
    //

    void setAnnotationEnabled( const bool enabled ) { mShowGridAnnotation = enabled; }

    bool annotationEnabled() const { return mShowGridAnnotation; }

    void setAnnotationTextFormat( const QgsTextFormat &format ) { mAnnotationFormat = format; }

    QgsTextFormat annotationTextFormat() const { return mAnnotationFormat; }

    Q_DECL_DEPRECATED void setAnnotationFont( const QFont &font ) SIP_DEPRECATED;

    Q_DECL_DEPRECATED QFont annotationFont() const SIP_DEPRECATED;

    Q_DECL_DEPRECATED void setAnnotationFontColor( const QColor &color ) SIP_DEPRECATED;

    Q_DECL_DEPRECATED QColor annotationFontColor() const SIP_DEPRECATED;

    void setAnnotationPrecision( const int precision ) { mGridAnnotationPrecision = precision; }

    int annotationPrecision() const { return mGridAnnotationPrecision; }

    void setAnnotationDisplay( Qgis::MapGridComponentVisibility display, Qgis::MapGridBorderSide border );

    Qgis::MapGridComponentVisibility annotationDisplay( Qgis::MapGridBorderSide border ) const;

    void setAnnotationPosition( Qgis::MapGridAnnotationPosition position, Qgis::MapGridBorderSide side );

    Qgis::MapGridAnnotationPosition annotationPosition( Qgis::MapGridBorderSide side ) const;

    void setAnnotationFrameDistance( const double distance );

    double annotationFrameDistance() const { return mAnnotationFrameDistance; }

    void setAnnotationDirection( Qgis::MapGridAnnotationDirection direction, Qgis::MapGridBorderSide side );

    void setAnnotationDirection( Qgis::MapGridAnnotationDirection direction );

    Qgis::MapGridAnnotationDirection annotationDirection( Qgis::MapGridBorderSide border ) const;

    void setAnnotationFormat( const Qgis::MapGridAnnotationFormat format ) { mGridAnnotationFormat = format; }

    Qgis::MapGridAnnotationFormat annotationFormat() const { return mGridAnnotationFormat; }

    void setAnnotationExpression( const QString &expression );

    QString annotationExpression() const { return mGridAnnotationExpressionString; }
 
    //
    // GRID FRAME
    //

    void setFrameStyle( const Qgis::MapGridFrameStyle style ) { mGridFrameStyle = style; }

    Qgis::MapGridFrameStyle frameStyle() const { return mGridFrameStyle; }

    void setFrameDivisions( Qgis::MapGridComponentVisibility divisions, Qgis::MapGridBorderSide side );

    Qgis::MapGridComponentVisibility frameDivisions( Qgis::MapGridBorderSide side ) const;

    void setFrameSideFlags( Qgis::MapGridFrameSideFlags flags );

    void setFrameSideFlag( Qgis::MapGridFrameSideFlag flag, bool on = true );

    Qgis::MapGridFrameSideFlags frameSideFlags() const;

    bool testFrameSideFlag( Qgis::MapGridFrameSideFlag flag ) const;

    void setFrameWidth( const double width );

    double frameWidth() const { return mGridFrameWidth; }

    void setRotatedTicksEnabled( const bool state ) { mRotatedTicksEnabled = state; }

    bool rotatedTicksEnabled() const { return mRotatedTicksEnabled; }

    void setRotatedTicksLengthMode( const Qgis::MapGridTickLengthMode mode ) { mRotatedTicksLengthMode = mode; }

    Qgis::MapGridTickLengthMode rotatedTicksLengthMode() const { return mRotatedTicksLengthMode; }

    void setRotatedTicksMinimumAngle( const double angle ) { mRotatedTicksMinimumAngle = angle; }

    double rotatedTicksMinimumAngle() const { return mRotatedTicksMinimumAngle; }

    void setRotatedTicksMarginToCorner( const double margin ) { mRotatedTicksMarginToCorner = margin; }

    double rotatedTicksMarginToCorner() const { return mRotatedTicksMarginToCorner; }

    void setRotatedAnnotationsEnabled( const bool state ) { mRotatedAnnotationsEnabled = state; }

    bool rotatedAnnotationsEnabled() const { return mRotatedAnnotationsEnabled; }

    void setRotatedAnnotationsLengthMode( const Qgis::MapGridTickLengthMode mode ) { mRotatedAnnotationsLengthMode = mode; }

    Qgis::MapGridTickLengthMode rotatedAnnotationsLengthMode() const { return mRotatedAnnotationsLengthMode; }

    void setRotatedAnnotationsMinimumAngle( const double angle ) { mRotatedAnnotationsMinimumAngle = angle; }

    double rotatedAnnotationsMinimumAngle() const { return mRotatedAnnotationsMinimumAngle; }

    void setRotatedAnnotationsMarginToCorner( const double margin ) { mRotatedAnnotationsMarginToCorner = margin; }

    double rotatedAnnotationsMarginToCorner() const { return mRotatedAnnotationsMarginToCorner; }

    void setFrameMargin( const double margin );

    double frameMargin() const { return mGridFrameMargin; }

    void setFramePenSize( const double width );

    double framePenSize() const { return mGridFramePenThickness; }

    void setFramePenColor( const QColor &color ) { mGridFramePenColor = color; }

    QColor framePenColor() const { return mGridFramePenColor; }

    void setFrameFillColor1( const QColor &color ) { mGridFrameFillColor1 = color; }

    QColor frameFillColor1() const { return mGridFrameFillColor1; }

    void setFrameFillColor2( const QColor &color ) { mGridFrameFillColor2 = color; }

    QColor frameFillColor2() const { return mGridFrameFillColor2; }

    Qgis::TextHorizontalAlignment horizontalAlignment() const;

    void setHorizontalAlignment( Qgis::TextHorizontalAlignment alignment );
 
    QgsExpressionContext createExpressionContext() const override;
    bool accept( QgsStyleEntityVisitorInterface *visitor ) const override;
    void refresh() override;

    void copyProperties( const QgsLayoutItemMapGrid *other );
 
  signals:

    void crsChanged();
 
  private:
    QgsLayoutItemMapGrid() = delete;
 
    static constexpr int MAX_GRID_LINES = 1000;
    static constexpr int MAX_GRID_ANNOTATIONS = 1000;
    static constexpr int MAX_GRID_TICKS = 5000;
    static constexpr int MAX_GRID_FRAME_OBJECTS = std::max( MAX_GRID_TICKS, MAX_GRID_ANNOTATIONS );
    static constexpr int MAX_GRID_OBJECTS = std::max( MAX_GRID_LINES, MAX_GRID_FRAME_OBJECTS );
 
    struct GridExtension
    {
        GridExtension() = default;
        double top = 0.0;
        double right = 0.0;
        double bottom = 0.0;
        double left = 0.0;

        void UpdateBorder( Qgis::MapGridBorderSide border, double value )
        {
          switch ( border )
          {
            case Qgis::MapGridBorderSide::Left:
              left = std::max( left, value );
              break;
            case Qgis::MapGridBorderSide::Right:
              right = std::max( right, value );
              break;
            case Qgis::MapGridBorderSide::Top:
              top = std::max( top, value );
              break;
            case Qgis::MapGridBorderSide::Bottom:
              bottom = std::max( bottom, value );
              break;
          }
        }

        void UpdateAll( double value )
        {
          left = std::max( left, value );
          right = std::max( right, value );
          top = std::max( top, value );
          bottom = std::max( bottom, value );
        }
    };
 
    static constexpr double GRID_LINE_CLOSE_TO_EDGE_TOLERANCE_MAP_UNITS = 0.00001;
 
    // we need a little bit of tolerance for showing annotations right at the extremities of their edges,
    // as we don't want to omit annotations right at the map edges if rounding errors have occurred in the position math
    static constexpr double ANNOTATION_CLOSE_TO_EDGE_TOLERANCE_MM = 0.01;
 
    struct GridLineAnnotation
    {
        Qgis::MapGridBorderSide border = Qgis::MapGridBorderSide::Left; // border on which the annotation is
        QVector2D position;                                             // position on the frame
        QVector2D vector;                                               // vector towards map center
        double angle = 0;                                               // the (acute) angle formed between the vector and the border
    };

    struct GridLine
    {
        QPolygonF line;                             // the actual line, can be straight with two points or curved if transformed
        double coordinate;                          // the coordinate value
        Qgis::MapGridAnnotationType coordinateType; // whether it's a latitude or longitude line
        GridLineAnnotation startAnnotation;         // the annotation on the start point
        GridLineAnnotation endAnnotation;           // the annotation on the end point
    };
    mutable QList< GridLine > mGridLines;

    mutable bool mTransformDirty = true;

    Qgis::MapGridStyle mGridStyle = Qgis::MapGridStyle::Lines;
    double mGridIntervalX = 0.0;
    double mGridIntervalY = 0.0;
    double mGridOffsetX = 0.0;
    double mGridOffsetY = 0.0;

    QgsTextFormat mAnnotationFormat;

    int mGridAnnotationPrecision = 3;
    bool mShowGridAnnotation = false;
 
    Qgis::TextHorizontalAlignment mHAlign = Qgis::TextHorizontalAlignment::Center;

    Qgis::MapGridComponentVisibility mLeftGridAnnotationDisplay = Qgis::MapGridComponentVisibility::ShowAll;
    Qgis::MapGridComponentVisibility mRightGridAnnotationDisplay = Qgis::MapGridComponentVisibility::ShowAll;
    Qgis::MapGridComponentVisibility mTopGridAnnotationDisplay = Qgis::MapGridComponentVisibility::ShowAll;
    Qgis::MapGridComponentVisibility mBottomGridAnnotationDisplay = Qgis::MapGridComponentVisibility::ShowAll;

    Qgis::MapGridAnnotationPosition mLeftGridAnnotationPosition = Qgis::MapGridAnnotationPosition::OutsideMapFrame;
    Qgis::MapGridAnnotationPosition mRightGridAnnotationPosition = Qgis::MapGridAnnotationPosition::OutsideMapFrame;
    Qgis::MapGridAnnotationPosition mTopGridAnnotationPosition = Qgis::MapGridAnnotationPosition::OutsideMapFrame;
    Qgis::MapGridAnnotationPosition mBottomGridAnnotationPosition = Qgis::MapGridAnnotationPosition::OutsideMapFrame;

    double mAnnotationFrameDistance = 1.0;

    Qgis::MapGridAnnotationDirection mLeftGridAnnotationDirection = Qgis::MapGridAnnotationDirection::Horizontal;
    Qgis::MapGridAnnotationDirection mRightGridAnnotationDirection = Qgis::MapGridAnnotationDirection::Horizontal;
    Qgis::MapGridAnnotationDirection mTopGridAnnotationDirection = Qgis::MapGridAnnotationDirection::Horizontal;
    Qgis::MapGridAnnotationDirection mBottomGridAnnotationDirection = Qgis::MapGridAnnotationDirection::Horizontal;
    Qgis::MapGridAnnotationFormat mGridAnnotationFormat = Qgis::MapGridAnnotationFormat::Decimal;
 
    QString mGridAnnotationExpressionString;
    mutable std::unique_ptr< QgsExpression > mGridAnnotationExpression;
 
    Qgis::MapGridFrameStyle mGridFrameStyle = Qgis::MapGridFrameStyle::NoFrame;
 
    Qgis::MapGridFrameSideFlags mGridFrameSides;
    double mGridFrameWidth = 2.0;
    double mGridFramePenThickness = 0.3;
    QColor mGridFramePenColor = QColor( 0, 0, 0 );
    QColor mGridFrameFillColor1 = Qt::white;
    QColor mGridFrameFillColor2 = Qt::black;
    double mCrossLength = 3.0;
    double mGridFrameMargin = 0.0;
    bool mRotatedTicksEnabled = false;
    Qgis::MapGridTickLengthMode mRotatedTicksLengthMode = Qgis::MapGridTickLengthMode::OrthogonalTicks;
    double mRotatedTicksMinimumAngle = 0.0;
    double mRotatedTicksMarginToCorner = 0.0;
    bool mRotatedAnnotationsEnabled = false;
    Qgis::MapGridTickLengthMode mRotatedAnnotationsLengthMode = Qgis::MapGridTickLengthMode::OrthogonalTicks;
    double mRotatedAnnotationsMinimumAngle = 0.0;
    double mRotatedAnnotationsMarginToCorner = 0.0;
 
    double mMinimumIntervalWidth = 50;
    double mMaximumIntervalWidth = 100;

    Qgis::MapGridComponentVisibility mLeftFrameDivisions = Qgis::MapGridComponentVisibility::ShowAll;
    Qgis::MapGridComponentVisibility mRightFrameDivisions = Qgis::MapGridComponentVisibility::ShowAll;
    Qgis::MapGridComponentVisibility mTopFrameDivisions = Qgis::MapGridComponentVisibility::ShowAll;
    Qgis::MapGridComponentVisibility mBottomFrameDivisions = Qgis::MapGridComponentVisibility::ShowAll;
 
    std::unique_ptr< QgsLineSymbol > mGridLineSymbol;
    std::unique_ptr< QgsMarkerSymbol > mGridMarkerSymbol;
 
    QgsCoordinateReferenceSystem mCRS;
 
    Qgis::MapGridUnit mGridUnit = Qgis::MapGridUnit::MapUnits;
 
    QPainter::CompositionMode mBlendMode = QPainter::CompositionMode_SourceOver;
 
    mutable QList< QPair< double, QPolygonF > > mTransformedXLines;
    mutable QList< QPair< double, QPolygonF > > mTransformedYLines;
    mutable QList< QgsPointXY > mTransformedIntersections;
    QRectF mPrevPaintRect;
    mutable QPolygonF mPrevMapPolygon;
 
    bool mEvaluatedEnabled = true;
    double mEvaluatedIntervalX = 0;
    double mEvaluatedIntervalY = 0;
    double mEvaluatedOffsetX = 0;
    double mEvaluatedOffsetY = 0;
    double mEvaluatedGridFrameWidth = 0;
    double mEvaluatedGridFrameMargin = 0;
    double mEvaluatedAnnotationFrameDistance = 0;
    double mEvaluatedCrossLength = 0;
    double mEvaluatedGridFrameLineThickness = 0;
    std::unique_ptr< QgsProperty > mDrawAnnotationProperty;
    Qgis::MapGridComponentVisibility mEvaluatedLeftGridAnnotationDisplay = Qgis::MapGridComponentVisibility::ShowAll;
    Qgis::MapGridComponentVisibility mEvaluatedRightGridAnnotationDisplay = Qgis::MapGridComponentVisibility::ShowAll;
    Qgis::MapGridComponentVisibility mEvaluatedTopGridAnnotationDisplay = Qgis::MapGridComponentVisibility::ShowAll;
    Qgis::MapGridComponentVisibility mEvaluatedBottomGridAnnotationDisplay = Qgis::MapGridComponentVisibility::ShowAll;
    Qgis::MapGridComponentVisibility mEvaluatedLeftFrameDivisions = Qgis::MapGridComponentVisibility::ShowAll;
    Qgis::MapGridComponentVisibility mEvaluatedRightFrameDivisions = Qgis::MapGridComponentVisibility::ShowAll;
    Qgis::MapGridComponentVisibility mEvaluatedTopFrameDivisions = Qgis::MapGridComponentVisibility::ShowAll;
    Qgis::MapGridComponentVisibility mEvaluatedBottomFrameDivisions = Qgis::MapGridComponentVisibility::ShowAll;
 
    mutable int mCurrentComponentDrawCount = 0;

    void updateGridLinesAnnotationsPositions() const;

    void drawGridFrame( QPainter *p, GridExtension *extension = nullptr ) const;

    void drawCoordinateAnnotations( QgsRenderContext &context, QgsExpressionContext &expressionContext, GridExtension *extension = nullptr ) const;

    void drawCoordinateAnnotation( QgsRenderContext &context, GridLineAnnotation annot, const QString &annotationString, Qgis::MapGridAnnotationType coordinateType, GridExtension *extension = nullptr ) const;
 
    QString gridAnnotationString( double value, Qgis::MapGridAnnotationType coord, QgsExpressionContext &expressionContext, bool isGeographic ) const;

    void calculateXGridLines() const;

    void calculateYGridLines() const;
 
    int xGridLinesCrsTransform( const QgsRectangle &bbox, const QgsCoordinateTransform &t ) const;
 
    int yGridLinesCrsTransform( const QgsRectangle &bbox, const QgsCoordinateTransform &t ) const;
 
    void drawGridLine( const QLineF &line, QgsRenderContext &context ) const;
 
    void drawGridLine( const QPolygonF &line, QgsRenderContext &context ) const;

    void drawGridFrameBorder( QPainter *p, Qgis::MapGridBorderSide border, double *extension = nullptr ) const;

    Qgis::MapGridBorderSide borderForLineCoord( QPointF p, Qgis::MapGridAnnotationType coordinateType ) const;

    int crsGridParams( QgsRectangle &crsRect, QgsCoordinateTransform &inverseTransform ) const;
 
    static QList<QPolygonF> trimLinesToMap( const QPolygonF &line, const QgsRectangle &rect );
 
    QPolygonF scalePolygon( const QPolygonF &polygon, double scale ) const;

    void drawGridCrsTransform( QgsRenderContext &context, double dotsPerMM, bool calculateLinesOnly = false ) const;
 
    void drawGridNoTransform( QgsRenderContext &context, double dotsPerMM, bool calculateLinesOnly = false ) const;
 
    void createDefaultGridLineSymbol();
 
    void createDefaultGridMarkerSymbol();
 
    void drawGridMarker( QPointF point, QgsRenderContext &context ) const;
 
    void drawGridFrameZebra( QPainter *p, GridExtension *extension = nullptr ) const;
 
    void drawGridFrameZebraBorder( QPainter *p, Qgis::MapGridBorderSide border, double *extension = nullptr ) const;
 
    void drawGridFrameTicks( QPainter *p, GridExtension *extension = nullptr ) const;
 
    void drawGridFrameLine( QPainter *p, GridExtension *extension = nullptr ) const;
 
    void calculateCrsTransformLines() const;
 
    bool shouldShowDivisionForSide( Qgis::MapGridAnnotationType coordinate, Qgis::MapGridBorderSide side ) const;
    bool shouldShowAnnotationForSide( Qgis::MapGridAnnotationType coordinate, Qgis::MapGridBorderSide side ) const;
    bool shouldShowForDisplayMode( Qgis::MapGridAnnotationType coordinate, Qgis::MapGridComponentVisibility mode ) const;
    void refreshDataDefinedProperties();

    double mapWidth() const;
 
    friend class TestQgsLayoutMapGrid;
 
    // Needs access to evaluated properties to compute frame bleed
    friend class QgsLayoutItemMap;
};
 
 
#endif // QGSLAYOUTITEMMAPGRID_H