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 );
 
    QList< QgsLayoutItemMapGrid * > asList() const;
 
    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:
 
    enum GridUnit
    {
      MapUnit, 
      MM, 
      CM, 
      DynamicPageSizeBased, 
    };
 
    enum GridStyle
    {
      Solid = 0,
      Cross, 
      Markers, 
      FrameAnnotationsOnly 
    };
 
    enum DisplayMode
    {
      ShowAll = 0, 
      LatitudeOnly, 
      LongitudeOnly, 
      HideAll 
    };
 
    enum AnnotationPosition
    {
      InsideMapFrame = 0, 
      OutsideMapFrame, 
    };
 
    enum AnnotationDirection
    {
      Horizontal = 0, 
      Vertical, 
      VerticalDescending, 
      BoundaryDirection, 
      AboveTick, 
      OnTick, 
      UnderTick, 
    };
 
    enum AnnotationFormat
    {
      Decimal = 0, 
      DegreeMinute, 
      DegreeMinuteSecond, 
      DecimalWithSuffix, 
      DegreeMinuteNoSuffix, 
      DegreeMinutePadded, 
      DegreeMinuteSecondNoSuffix, 
      DegreeMinuteSecondPadded, 
      CustomFormat 
    };
 
    enum BorderSide
    {
      Left, 
      Right, 
      Bottom, 
      Top, 
    };
 
    enum FrameStyle
    {
      NoFrame = 0, 
      Zebra, 
      InteriorTicks,  
      ExteriorTicks,  
      InteriorExteriorTicks, 
      LineBorder, 
      LineBorderNautical, 
      ZebraNautical, 
    };
 
    enum TickLengthMode
    {
      OrthogonalTicks = 0, 
      NormalizedTicks, 
    };
 
    enum FrameSideFlag SIP_ENUM_BASETYPE( IntFlag )
    {
      FrameLeft = 0x01, 
      FrameRight = 0x02, 
      FrameTop = 0x04, 
      FrameBottom = 0x08 
    };
    Q_DECLARE_FLAGS( FrameSideFlags, FrameSideFlag )
 
    
    enum AnnotationCoordinate
    {
      Longitude = 0, 
      Latitude 
    };
 
    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( GridUnit unit );
 
    GridUnit 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( GridStyle style );
 
    GridStyle 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( DisplayMode display, BorderSide border );
 
    DisplayMode annotationDisplay( BorderSide border ) const;
 
    void setAnnotationPosition( AnnotationPosition position, BorderSide side );
 
    AnnotationPosition annotationPosition( BorderSide side ) const;
 
    void setAnnotationFrameDistance( const double distance );
 
    double annotationFrameDistance() const { return mAnnotationFrameDistance; }
 
    void setAnnotationDirection( AnnotationDirection direction, BorderSide side );
 
    void setAnnotationDirection( AnnotationDirection direction );
 
    AnnotationDirection annotationDirection( BorderSide border ) const;
 
    void setAnnotationFormat( const AnnotationFormat format ) { mGridAnnotationFormat = format; }
 
    AnnotationFormat annotationFormat() const { return mGridAnnotationFormat; }
 
    void setAnnotationExpression( const QString &expression );
 
    QString annotationExpression() const { return mGridAnnotationExpressionString; }
 
    //
    // GRID FRAME
    //
 
    void setFrameStyle( const FrameStyle style ) { mGridFrameStyle = style; }
 
    FrameStyle frameStyle() const { return mGridFrameStyle; }
 
    void setFrameDivisions( DisplayMode divisions, BorderSide side );
 
    DisplayMode frameDivisions( BorderSide side ) const;
 
    void setFrameSideFlags( QgsLayoutItemMapGrid::FrameSideFlags flags );
 
    void setFrameSideFlag( QgsLayoutItemMapGrid::FrameSideFlag flag, bool on = true );
 
    QgsLayoutItemMapGrid::FrameSideFlags frameSideFlags() const;
 
    bool testFrameSideFlag( FrameSideFlag flag ) const;
 
    void setFrameWidth( const double width );
 
    double frameWidth() const { return mGridFrameWidth; }
 
    void setRotatedTicksEnabled( const bool state ) { mRotatedTicksEnabled = state; }
 
    double rotatedTicksEnabled() const { return mRotatedTicksEnabled; }
 
    void setRotatedTicksLengthMode( const TickLengthMode mode ) { mRotatedTicksLengthMode = mode; }
 
    TickLengthMode 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; }
 
    double rotatedAnnotationsEnabled() const { return mRotatedAnnotationsEnabled; }
 
    void setRotatedAnnotationsLengthMode( const TickLengthMode mode ) { mRotatedAnnotationsLengthMode = mode; }
 
    TickLengthMode 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; }
 
    QgsExpressionContext createExpressionContext() const override;
    bool accept( QgsStyleEntityVisitorInterface *visitor ) const override;
    void refresh() override;
 
    void copyProperties( const QgsLayoutItemMapGrid *other );
 
  signals:
 
    void crsChanged();
 
  private:
 
    QgsLayoutItemMapGrid() = delete;
 
    struct GridExtension
    {
      GridExtension() = default;
      double top = 0.0;
      double right = 0.0;
      double bottom = 0.0;
      double left = 0.0;
 
      void UpdateBorder( BorderSide border, double value )
      {
        switch ( border )
        {
          case QgsLayoutItemMapGrid::Left:
            left = std::max( left, value );
            break;
          case QgsLayoutItemMapGrid::Right:
            right = std::max( right, value );
            break;
          case QgsLayoutItemMapGrid::Top:
            top = std::max( top, value );
            break;
          case QgsLayoutItemMapGrid::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 );
      }
    };
 
    struct GridLineAnnotation
    {
      BorderSide border = 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
      QgsLayoutItemMapGrid::AnnotationCoordinate 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;
 
    GridStyle mGridStyle = QgsLayoutItemMapGrid::Solid;
    double mGridIntervalX = 0.0;
    double mGridIntervalY = 0.0;
    double mGridOffsetX = 0.0;
    double mGridOffsetY = 0.0;
 
    QgsTextFormat mAnnotationFormat;
 
    int mGridAnnotationPrecision = 3;
    bool mShowGridAnnotation = false;
 
    DisplayMode mLeftGridAnnotationDisplay = QgsLayoutItemMapGrid::ShowAll;
    DisplayMode mRightGridAnnotationDisplay = QgsLayoutItemMapGrid::ShowAll;
    DisplayMode mTopGridAnnotationDisplay = QgsLayoutItemMapGrid::ShowAll;
    DisplayMode mBottomGridAnnotationDisplay = QgsLayoutItemMapGrid::ShowAll;
 
    AnnotationPosition mLeftGridAnnotationPosition = QgsLayoutItemMapGrid::OutsideMapFrame;
    AnnotationPosition mRightGridAnnotationPosition = QgsLayoutItemMapGrid::OutsideMapFrame;
    AnnotationPosition mTopGridAnnotationPosition = QgsLayoutItemMapGrid::OutsideMapFrame;
    AnnotationPosition mBottomGridAnnotationPosition = QgsLayoutItemMapGrid::OutsideMapFrame;
 
    double mAnnotationFrameDistance = 1.0;
 
    AnnotationDirection mLeftGridAnnotationDirection = QgsLayoutItemMapGrid::Horizontal;
    AnnotationDirection mRightGridAnnotationDirection = QgsLayoutItemMapGrid::Horizontal;
    AnnotationDirection mTopGridAnnotationDirection = QgsLayoutItemMapGrid::Horizontal;
    AnnotationDirection mBottomGridAnnotationDirection = QgsLayoutItemMapGrid::Horizontal;
    AnnotationFormat mGridAnnotationFormat = QgsLayoutItemMapGrid::Decimal;
 
    QString mGridAnnotationExpressionString;
    mutable std::unique_ptr< QgsExpression > mGridAnnotationExpression;
 
    FrameStyle mGridFrameStyle = QgsLayoutItemMapGrid::NoFrame;
 
    FrameSideFlags 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;
    TickLengthMode mRotatedTicksLengthMode = QgsLayoutItemMapGrid::OrthogonalTicks;
    double mRotatedTicksMinimumAngle = 0.0;
    double mRotatedTicksMarginToCorner = 0.0;
    bool mRotatedAnnotationsEnabled = false;
    TickLengthMode mRotatedAnnotationsLengthMode = QgsLayoutItemMapGrid::OrthogonalTicks;
    double mRotatedAnnotationsMinimumAngle = 0.0;
    double mRotatedAnnotationsMarginToCorner = 0.0;
 
    double mMinimumIntervalWidth = 50;
    double mMaximumIntervalWidth = 100;
 
    DisplayMode mLeftFrameDivisions = QgsLayoutItemMapGrid::ShowAll;
    DisplayMode mRightFrameDivisions = QgsLayoutItemMapGrid::ShowAll;
    DisplayMode mTopFrameDivisions = QgsLayoutItemMapGrid::ShowAll;
    DisplayMode mBottomFrameDivisions = QgsLayoutItemMapGrid::ShowAll;
 
    std::unique_ptr< QgsLineSymbol > mGridLineSymbol;
    std::unique_ptr< QgsMarkerSymbol > mGridMarkerSymbol;
 
    QgsCoordinateReferenceSystem mCRS;
 
    GridUnit mGridUnit = MapUnit;
 
    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;
    DisplayMode mEvaluatedLeftGridAnnotationDisplay = QgsLayoutItemMapGrid::ShowAll;
    DisplayMode mEvaluatedRightGridAnnotationDisplay = QgsLayoutItemMapGrid::ShowAll;
    DisplayMode mEvaluatedTopGridAnnotationDisplay = QgsLayoutItemMapGrid::ShowAll;
    DisplayMode mEvaluatedBottomGridAnnotationDisplay = QgsLayoutItemMapGrid::ShowAll;
    DisplayMode mEvaluatedLeftFrameDivisions = QgsLayoutItemMapGrid::ShowAll;
    DisplayMode mEvaluatedRightFrameDivisions = QgsLayoutItemMapGrid::ShowAll;
    DisplayMode mEvaluatedTopFrameDivisions = QgsLayoutItemMapGrid::ShowAll;
    DisplayMode mEvaluatedBottomFrameDivisions = QgsLayoutItemMapGrid::ShowAll;
 
    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, AnnotationCoordinate coordinateType, GridExtension *extension = nullptr ) const;
 
    QString gridAnnotationString( double value, AnnotationCoordinate coord, QgsExpressionContext &expressionContext ) const;
 
    int xGridLines() const;
 
    int yGridLines() 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, BorderSide border, double *extension = nullptr ) const;
 
    BorderSide borderForLineCoord( QPointF p, AnnotationCoordinate 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, BorderSide 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( AnnotationCoordinate coordinate, BorderSide side ) const;
    bool shouldShowAnnotationForSide( AnnotationCoordinate coordinate, BorderSide side ) const;
    bool shouldShowForDisplayMode( AnnotationCoordinate coordinate, DisplayMode mode ) const;
    void refreshDataDefinedProperties();
 
    double mapWidth() const;
 
    friend class TestQgsLayoutMapGrid;
 
    // Needs access to evaluated properties to compute frame bleed
    friend class QgsLayoutItemMap;
 
};
 
Q_DECLARE_OPERATORS_FOR_FLAGS( QgsLayoutItemMapGrid::FrameSideFlags )
 
#endif // QGSLAYOUTITEMMAPGRID_H