qgscomposermapgrid.h

Go to the documentation of this file.

/***************************************************************************
                         qgscomposermapgrid.h
                         --------------------
    begin                : December 2013
    copyright            : (C) 2013 by Marco Hugentobler
    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 QGSCOMPOSERMAPGRID_H
#define QGSCOMPOSERMAPGRID_H

#include "qgscomposermapitem.h"
#include "qgscoordinatereferencesystem.h"
#include "qgsrectangle.h"
#include "qgsrendercontext.h"
#include <QString>
#include <QPainter>

class QgsCoordinateTransform;
class QgsLineSymbolV2;
class QgsMarkerSymbolV2;
class QgsComposerMapGrid;
class QgsComposerMap;
class QDomDocument;
class QDomElement;
class QPainter;

class CORE_EXPORT QgsComposerMapGridStack : public QgsComposerMapItemStack
{
  public:

    QgsComposerMapGridStack( QgsComposerMap* map );

    virtual ~QgsComposerMapGridStack();

    void addGrid( QgsComposerMapGrid* grid );

    void removeGrid( const QString& gridId );

    void moveGridUp( const QString& gridId );

    void moveGridDown( const QString& gridId );

    const QgsComposerMapGrid* constGrid( const QString& gridId ) const;

    QgsComposerMapGrid* grid( const QString& gridId ) const;

    QgsComposerMapGrid* grid( const int index ) const;

    QgsComposerMapGrid &operator[]( int idx );

    QList< QgsComposerMapGrid* > asList() const;

    bool readXML( const QDomElement& elem, const QDomDocument& doc ) override;

    double maxGridExtension() const;

};

//
// QgsComposerMapGrid
//

class CORE_EXPORT QgsComposerMapGrid : public QgsComposerMapItem
{

    Q_OBJECT

  public:

    enum GridUnit
    {
      MapUnit, /*< grid units follow map units */
      MM, /*< grid units in millimetres */
      CM /*< grid units in centimetres */
    };

    enum GridStyle
    {
      Solid = 0,
      Cross, /*< draw line crosses at intersections of grid lines */
      Markers, /*< draw markers at intersections of grid lines */
      FrameAnnotationsOnly /*< no grid lines over the map, only draw frame and annotations */
    };

    enum DisplayMode
    {
      ShowAll = 0, /*< show both latitude and longitude annotations/divisions */
      LatitudeOnly, /*< show latitude/y annotations/divisions only */
      LongitudeOnly, /*< show longitude/x annotations/divisions only */
      HideAll /*< no annotations */
    };

    enum AnnotationPosition
    {
      InsideMapFrame = 0,
      OutsideMapFrame, /*< draw annotations outside the map frame */
      Disabled /*< disable annotation
                  * @deprecated in QGIS 2.7, use QgsComposerMapGrid::HideAll instead */
    };

    enum AnnotationDirection
    {
      Horizontal = 0, /*< draw annotations horizontally */
      Vertical, /*< draw annotations vertically, ascending */
      VerticalDescending, /*< draw annotations vertically, descending */
      BoundaryDirection /*< annotations follow the boundary direction */
    };

    enum AnnotationFormat
    {
      Decimal = 0, /*< decimal degrees, use - for S/W coordinates */
      DegreeMinute, /*< degree/minutes, use NSEW suffix */
      DegreeMinuteSecond, /*< degree/minutes/seconds, use NSEW suffix */
      DecimalWithSuffix, /*< decimal degrees, use NSEW suffix */
      DegreeMinuteNoSuffix, /*< degree/minutes, use - for S/W coordinates */
      DegreeMinutePadded, /*< degree/minutes, with minutes using leading zeros were required */
      DegreeMinuteSecondNoSuffix, /*< degree/minutes/seconds, use - for S/W coordinates */
      DegreeMinuteSecondPadded /*< degree/minutes/seconds, with minutes using leading zeros were required */
    };

    enum BorderSide
    {
      Left,
      Right, /*< right border */
      Bottom, /*< bottom border */
      Top /*< top border */
    };

    enum FrameStyle
    {
      NoFrame = 0, /*< disable grid frame */
      Zebra, /*< black/white pattern */
      InteriorTicks,  /*< tick markers drawn inside map frame */
      ExteriorTicks,  /*< tick markers drawn outside map frame */
      InteriorExteriorTicks, /*< tick markers drawn both inside and outside the map frame */
      LineBorder /*< simple solid line frame */
    };

    enum FrameSideFlag
    {
      FrameLeft = 0x01, /*< left side of map */
      FrameRight = 0x02, /*< right side of map */
      FrameTop = 0x04, /*< top side of map */
      FrameBottom = 0x08 /*< bottom side of map */
    };
    Q_DECLARE_FLAGS( FrameSideFlags, FrameSideFlag )

    
    enum AnnotationCoordinate
    {
      Longitude = 0, /*< coordinate is a longitude value */
      Latitude /*< coordinate is a latitude value */
    };

    QgsComposerMapGrid( const QString& name, QgsComposerMap* map );

    virtual ~QgsComposerMapGrid();

    void draw( QPainter* painter ) override;

    bool writeXML( QDomElement& elem, QDomDocument & doc ) const override;

    bool readXML( const QDomElement& itemElem, const QDomDocument& doc ) 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;

    //
    // GRID UNITS
    //

    void setUnits( const GridUnit unit );

    GridUnit units() const { return mGridUnit; }

    void setIntervalX( const double interval );

    double intervalX() const { return mGridIntervalX; }

    void setIntervalY( const double interval );

    double intervalY() const { return mGridIntervalY; }

    void setOffsetX( const double offset );

    double offsetX() const { return mGridOffsetX; }

    void setOffsetY( const double offset );

    double offsetY() const { return mGridOffsetY; }

    //
    // GRID APPEARANCE
    //

    void setStyle( const GridStyle style );

    GridStyle style() const { return mGridStyle; }

    void setCrossLength( const double length ) { mCrossLength = length; }

    double crossLength() const { return mCrossLength; }

    void setGridLineWidth( const double width );

    void setGridLineColor( const QColor& color );

    void setLineSymbol( QgsLineSymbolV2* symbol );

    const QgsLineSymbolV2* lineSymbol() const { return mGridLineSymbol; }

    QgsLineSymbolV2* lineSymbol() { return mGridLineSymbol; }

    void setMarkerSymbol( QgsMarkerSymbolV2* symbol );

    const QgsMarkerSymbolV2* markerSymbol() const { return mGridMarkerSymbol; }

    QgsMarkerSymbolV2* markerSymbol() { return mGridMarkerSymbol; }

    //
    // ANNOTATIONS
    //

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

    bool annotationEnabled() const { return mShowGridAnnotation; }

    void setAnnotationFont( const QFont& font ) { mGridAnnotationFont = font; }

    QFont annotationFont() const { return mGridAnnotationFont; }

    void setAnnotationFontColor( const QColor& color ) { mGridAnnotationFontColor = color; }

    QColor annotationFontColor() const { return mGridAnnotationFontColor; }

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

    int annotationPrecision() const { return mGridAnnotationPrecision; }

    void setAnnotationDisplay( const DisplayMode display, const BorderSide border );

    DisplayMode annotationDisplay( const BorderSide border ) const;

    void setAnnotationPosition( const AnnotationPosition position, const BorderSide border );

    AnnotationPosition annotationPosition( const BorderSide border ) const;

    void setAnnotationFrameDistance( const double distance ) { mAnnotationFrameDistance = distance; }

    double annotationFrameDistance() const { return mAnnotationFrameDistance; }

    void setAnnotationDirection( const AnnotationDirection direction, const BorderSide border );

    void setAnnotationDirection( const AnnotationDirection direction );

    AnnotationDirection annotationDirection( const BorderSide border ) const;

    void setAnnotationFormat( const AnnotationFormat format ) { mGridAnnotationFormat = format; }

    AnnotationFormat annotationFormat() const { return mGridAnnotationFormat; }

    //
    // GRID FRAME
    //

    void setFrameStyle( const FrameStyle style ) { mGridFrameStyle = style; }

    FrameStyle frameStyle() const { return mGridFrameStyle; }

    void setFrameDivisions( const DisplayMode divisions, const BorderSide border );

    DisplayMode frameDivisions( const BorderSide border ) const;

    void setFrameSideFlags( const FrameSideFlags flags );

    void setFrameSideFlag( const FrameSideFlag flag, bool on = true );

    FrameSideFlags frameSideFlags() const;

    bool testFrameSideFlag( const FrameSideFlag flag ) const;

    void setFrameWidth( const double width ) { mGridFrameWidth = width; }

    double frameWidth() const { return mGridFrameWidth; }

    void setFramePenSize( const double width ) { mGridFramePenThickness = 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; }

  private:

    QgsComposerMapGrid(); //forbidden

    /*True if a re-transformation of grid lines is required*/
    bool mTransformDirty;

    GridStyle mGridStyle;
    double mGridIntervalX;
    double mGridIntervalY;
    double mGridOffsetX;
    double mGridOffsetY;
    QFont mGridAnnotationFont;
    QColor mGridAnnotationFontColor;
    int mGridAnnotationPrecision;
    bool mShowGridAnnotation;

    DisplayMode mLeftGridAnnotationDisplay;
    DisplayMode mRightGridAnnotationDisplay;
    DisplayMode mTopGridAnnotationDisplay;
    DisplayMode mBottomGridAnnotationDisplay;

    AnnotationPosition mLeftGridAnnotationPosition;
    AnnotationPosition mRightGridAnnotationPosition;
    AnnotationPosition mTopGridAnnotationPosition;
    AnnotationPosition mBottomGridAnnotationPosition;

    double mAnnotationFrameDistance;

    AnnotationDirection mLeftGridAnnotationDirection;
    AnnotationDirection mRightGridAnnotationDirection;
    AnnotationDirection mTopGridAnnotationDirection;
    AnnotationDirection mBottomGridAnnotationDirection;
    AnnotationFormat mGridAnnotationFormat;
    FrameStyle mGridFrameStyle;
    FrameSideFlags mGridFrameSides;
    double mGridFrameWidth;
    double mGridFramePenThickness;
    QColor mGridFramePenColor;
    QColor mGridFrameFillColor1;
    QColor mGridFrameFillColor2;
    double mCrossLength;

    DisplayMode mLeftFrameDivisions;
    DisplayMode mRightFrameDivisions;
    DisplayMode mTopFrameDivisions;
    DisplayMode mBottomFrameDivisions;

    QgsLineSymbolV2* mGridLineSymbol;
    QgsMarkerSymbolV2* mGridMarkerSymbol;

    QgsCoordinateReferenceSystem mCRS;

    GridUnit mGridUnit;

    QPainter::CompositionMode mBlendMode;

    QList< QPair< double, QPolygonF > > mTransformedXLines;
    QList< QPair< double, QPolygonF > > mTransformedYLines;
    QList< QgsPoint > mTransformedIntersections;
    QRectF mPrevPaintRect;
    QPolygonF mPrevMapPolygon;

    class QgsMapAnnotation
    {
      public:
        double coordinate;
        QPointF itemPosition;
        QgsComposerMapGrid::AnnotationCoordinate coordinateType;
    };

    void init();

    void drawGridFrame( QPainter* p, const QList< QPair< double, QLineF > >& hLines, const QList< QPair< double, QLineF > >& vLines ) const;

    void drawCoordinateAnnotations( QPainter* p, const QList< QPair< double, QLineF > >& hLines, const QList< QPair< double, QLineF > >& vLines ) const;

    void drawCoordinateAnnotation( QPainter* p, const QPointF& pos, QString annotationString, const AnnotationCoordinate coordinateType ) const;

    void drawAnnotation( QPainter* p, const QPointF& pos, int rotation, const QString& annotationText ) const;

    QString gridAnnotationString( double value, AnnotationCoordinate coord ) const;

    int xGridLines( QList< QPair< double, QLineF > >& lines ) const;

    int yGridLines( QList< QPair< double, QLineF > >& lines ) const;

    int xGridLinesCRSTransform( const QgsRectangle& bbox, const QgsCoordinateTransform& t, QList< QPair< double, QPolygonF > >& lines ) const;

    int yGridLinesCRSTransform( const QgsRectangle& bbox, const QgsCoordinateTransform& t, QList< QPair< double, QPolygonF > >& lines ) const;

    void drawGridLine( const QLineF& line, QgsRenderContext &context ) const;

    void drawGridLine( const QPolygonF& line, QgsRenderContext &context ) const;

    void sortGridLinesOnBorders( const QList< QPair< double, QLineF > >& hLines, const QList< QPair< double, QLineF > >& vLines, QMap< double, double >& leftFrameEntries,
                                 QMap< double, double >& rightFrameEntries, QMap< double, double >& topFrameEntries, QMap< double, double >& bottomFrameEntries ) const;

    void drawGridFrameBorder( QPainter* p, const QMap< double, double >& borderPos, BorderSide border ) const;

    BorderSide borderForLineCoord( const QPointF& p, const 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, const double scale ) const;

    void drawGridCRSTransform( QgsRenderContext &context, double dotsPerMM, QList< QPair< double, QLineF > > &horizontalLines,
                               QList< QPair< double, QLineF > > &verticalLines );

    void drawGridNoTransform( QgsRenderContext &context, double dotsPerMM, QList<QPair<double, QLineF> > &horizontalLines, QList<QPair<double, QLineF> > &verticalLines ) const;

    void createDefaultGridLineSymbol();

    void createDefaultGridMarkerSymbol();

    void drawGridMarker( const QPointF &point, QgsRenderContext &context ) const;

    void drawGridFrameZebraBorder( QPainter *p, const QMap<double, double> &borderPos, BorderSide border ) const;

    void drawGridFrameTicks( QPainter *p, const QMap<double, double> &borderPos, BorderSide border ) const;

    void drawGridFrameLineBorder( QPainter *p, BorderSide border ) const;

    void calculateCRSTransformLines();

    bool shouldShowDivisionForSide( const AnnotationCoordinate &coordinate, const QgsComposerMapGrid::BorderSide& side ) const;
    bool shouldShowDivisionForDisplayMode( const QgsComposerMapGrid::AnnotationCoordinate &coordinate, const QgsComposerMapGrid::DisplayMode &mode ) const;

    friend class TestQgsComposerMapGrid;
};

Q_DECLARE_OPERATORS_FOR_FLAGS( QgsComposerMapGrid::FrameSideFlags )

#endif // QGSCOMPOSERMAPGRID_H