qgscomposermap.h

Go to the documentation of this file.

/***************************************************************************
                         qgscomposermap.h
                             -------------------
    begin                : January 2005
    copyright            : (C) 2005 by Radim Blazek
    email                : [email protected]
 ***************************************************************************/

/***************************************************************************
 *                                                                         *
 *   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 QGSCOMPOSERMAP_H
#define QGSCOMPOSERMAP_H

//#include "ui_qgscomposermapbase.h"
#include "qgscomposeritem.h"
#include "qgsrectangle.h"
#include <QFont>
#include <QGraphicsRectItem>

class QgsComposition;
class QgsMapRenderer;
class QgsMapToPixel;
class QDomNode;
class QDomDocument;
class QGraphicsView;
class QPainter;
class QgsFillSymbolV2;
class QgsLineSymbolV2;
class QgsVectorLayer;

// NOTE: QgsComposerMapBase must be first, otherwise does not compile
class CORE_EXPORT QgsComposerMap : public QgsComposerItem
{
    Q_OBJECT

  public:
    QgsComposerMap( QgsComposition *composition, int x, int y, int width, int height );
    QgsComposerMap( QgsComposition *composition );
    virtual ~QgsComposerMap();

    virtual int type() const { return ComposerMap; }

    enum PreviewMode
    {
      Cache = 0,   // Use raster cache
      Render,      // Render the map
      Rectangle    // Display only rectangle
    };

    enum GridStyle
    {
      Solid = 0, //solid lines
      Cross //only draw line crossings
    };

    enum GridAnnotationPosition
    {
      InsideMapFrame = 0,
      OutsideMapFrame,
      Disabled
    };

    enum GridAnnotationDirection
    {
      Horizontal = 0,
      Vertical,
      HorizontalAndVertical,
      BoundaryDirection
    };

    enum GridAnnotationFormat
    {
      Decimal = 0,
      DegreeMinute,
      DegreeMinuteSecond
    };

    enum GridFrameStyle
    {
      NoGridFrame = 0,
      Zebra //black / white pattern
    };

    enum Border
    {
      Left,
      Right,
      Bottom,
      Top
    };

    void draw( QPainter *painter, const QgsRectangle& extent, const QSizeF& size, double dpi, double* forceWidthScale = 0 );

    void paint( QPainter* painter, const QStyleOptionGraphicsItem* itemStyle, QWidget* pWidget );

    void cache();

    int id() const {return mId;}

    bool isDrawing() const {return mDrawing;}

    void resize( double dx, double dy );

    void moveContent( double dx, double dy );

    void zoomContent( int delta, double x, double y );

    void setSceneRect( const QRectF& rectangle );

    double scale() const;

    void setNewScale( double scaleDenominator );

    void setNewExtent( const QgsRectangle& extent );

    void setNewAtlasFeatureExtent( const QgsRectangle& extent );

    void toggleAtlasPreview();

    QgsRectangle* currentMapExtent();
    const QgsRectangle* currentMapExtent() const;

    PreviewMode previewMode() const {return mPreviewMode;}
    void setPreviewMode( PreviewMode m );

    bool keepLayerSet() const {return mKeepLayerSet;}
    void setKeepLayerSet( bool enabled ) {mKeepLayerSet = enabled;}

    QStringList layerSet() const {return mLayerSet;}
    void setLayerSet( const QStringList& layerSet ) {mLayerSet = layerSet;}
    void storeCurrentLayerSet();

    // Set cache outdated
    void setCacheUpdated( bool u = false );

    QgsRectangle extent() const {return mExtent;}

    const QgsMapRenderer* mapRenderer() const {return mMapRenderer;}

    void setOffset( double xOffset, double yOffset );

    bool containsWMSLayer() const;

    bool containsAdvancedEffects() const;

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

    bool readXML( const QDomElement& itemElem, const QDomDocument& doc );

    void setGridEnabled( bool enabled ) {mGridEnabled = enabled;}
    bool gridEnabled() const { return mGridEnabled; }

    void setGridStyle( GridStyle style ) {mGridStyle = style;}
    GridStyle gridStyle() const { return mGridStyle; }

    void setGridIntervalX( double interval ) { mGridIntervalX = interval;}
    double gridIntervalX() const { return mGridIntervalX; }

    void setGridIntervalY( double interval ) { mGridIntervalY = interval;}
    double gridIntervalY() const { return mGridIntervalY; }

    void setGridOffsetX( double offset ) { mGridOffsetX = offset; }
    double gridOffsetX() const { return mGridOffsetX; }

    void setGridOffsetY( double offset ) { mGridOffsetY = offset; }
    double gridOffsetY() const { return mGridOffsetY; }

    void setGridPen( const QPen& p );
    QPen gridPen() const;

    void setGridPenWidth( double w );

    void setGridPenColor( const QColor& c );

    void setGridAnnotationFont( const QFont& f ) { mGridAnnotationFont = f; }
    QFont gridAnnotationFont() const { return mGridAnnotationFont; }

    void setAnnotationFontColor( const QColor& c ) {mGridAnnotationFontColor = c;}
    QColor annotationFontColor() const {return mGridAnnotationFontColor;}

    void setGridAnnotationPrecision( int p ) {mGridAnnotationPrecision = p;}
    int gridAnnotationPrecision() const {return mGridAnnotationPrecision;}

    void setShowGridAnnotation( bool show ) {mShowGridAnnotation = show;}
    bool showGridAnnotation() const {return mShowGridAnnotation;}

    void setGridAnnotationPosition( GridAnnotationPosition p, QgsComposerMap::Border border );
    GridAnnotationPosition gridAnnotationPosition( QgsComposerMap::Border border ) const;

    void setAnnotationFrameDistance( double d ) {mAnnotationFrameDistance = d;}
    double annotationFrameDistance() const {return mAnnotationFrameDistance;}

    void setGridAnnotationDirection( GridAnnotationDirection d, QgsComposerMap::Border border );
    GridAnnotationDirection gridAnnotationDirection( QgsComposerMap::Border border ) const;

    void setGridAnnotationFormat( GridAnnotationFormat f ) { mGridAnnotationFormat = f; }
    GridAnnotationFormat gridAnnotationFormat() const { return mGridAnnotationFormat; }

    void setGridFrameStyle( GridFrameStyle style ) { mGridFrameStyle = style; }
    GridFrameStyle gridFrameStyle() const { return mGridFrameStyle; }

    void setGridFrameWidth( double w ) { mGridFrameWidth = w; }
    double gridFrameWidth() const { return mGridFrameWidth; }

    void setGridFramePenSize( double w ) { mGridFramePenThickness = w; }
    double gridFramePenSize() const { return mGridFramePenThickness; }

    void setGridFramePenColor( const QColor& c ) { mGridFramePenColor = c;}
    QColor gridFramePenColor() const {return mGridFramePenColor;}

    void setGridFrameFillColor1( const QColor& c ) { mGridFrameFillColor1 = c;}
    QColor gridFrameFillColor1() const {return mGridFrameFillColor1;}

    void setGridFrameFillColor2( const QColor& c ) { mGridFrameFillColor2 = c;}
    QColor gridFrameFillColor2() const {return mGridFrameFillColor2;}

    QRectF boundingRect() const;
    void updateBoundingRect();

    /* reimplement setFrameOutlineWidth, so that updateBoundingRect() is called after setting the frame width */
    virtual void setFrameOutlineWidth( double outlineWidth );

    void setCrossLength( double l ) {mCrossLength = l;}
    double crossLength() {return mCrossLength;}

    void setRotation( double r );
    double rotation() const { return mMapRotation;};

    void setMapRotation( double r );
    double mapRotation() const { return mMapRotation;};

    void updateItem();

    void setMapCanvas( QGraphicsView* canvas ) { mMapCanvas = canvas; }

    void setDrawCanvasItems( bool b ) { mDrawCanvasItems = b; }
    bool drawCanvasItems() const { return mDrawCanvasItems; }

    double mapUnitsToMM() const;

    void setOverviewFrameMap( int mapId );
    int overviewFrameMapId() const { return mOverviewFrameMapId; }

    void setOverviewFrameMapSymbol( QgsFillSymbolV2* symbol );
    QgsFillSymbolV2* overviewFrameMapSymbol() { return mOverviewFrameMapSymbol; }

    QPainter::CompositionMode overviewBlendMode() const {return mOverviewBlendMode;}
    void setOverviewBlendMode( QPainter::CompositionMode blendMode );

    bool overviewInverted() const {return mOverviewInverted;}
    void setOverviewInverted( bool inverted );

    bool overviewCentered() const { return mOverviewCentered; }
    void setOverviewCentered( bool centered );

    void setGridLineSymbol( QgsLineSymbolV2* symbol );
    QgsLineSymbolV2* gridLineSymbol() { return mGridLineSymbol; }

    QPainter::CompositionMode gridBlendMode() const {return mGridBlendMode;}
    void setGridBlendMode( QPainter::CompositionMode blendMode );

    void assignFreeId();

    bool imageSizeConsideringRotation( double& width, double& height ) const;
    bool cornerPointOnRotatedAndScaledRect( double& x, double& y, double width, double height ) const;
    void sizeChangedByRotation( double& width, double& height );

    bool atlasDriven() const { return mAtlasDriven; }
    void setAtlasDriven( bool enabled ) { mAtlasDriven = enabled; }

    bool atlasFixedScale() const { return mAtlasFixedScale; }
    void setAtlasFixedScale( bool fixed ) { mAtlasFixedScale = fixed; }

    double atlasMargin() const { return mAtlasMargin; }
    void setAtlasMargin( double margin ) { mAtlasMargin = margin; }

  signals:
    void extentChanged();

    void mapRotationChanged( double newRotation );

  public slots:

    void updateCachedImage( );
    void renderModeUpdateCachedImage();

    void overviewExtentChanged();

  private:

    enum AnnotationCoordinate
    {
      Longitude = 0,
      Latitude
    };

    // Pointer to map renderer of the QGIS main map. Note that QgsComposerMap uses a different map renderer,
    //it just copies some properties from the main map renderer.
    QgsMapRenderer *mMapRenderer;

    int mId;

    // Map region in map units realy used for rendering
    // It can be the same as mUserExtent, but it can be bigger in on dimension if mCalculate==Scale,
    // so that full rectangle in paper is used.
    QgsRectangle mExtent;

    // Current temporary map region in map units. This is overwritten when atlas feature changes. It's also
    // used when the user changes the map extent and an atlas preview is enabled. This allows the user
    // to manually tweak each atlas preview page without affecting the actual original map extent.
    QgsRectangle mAtlasFeatureExtent;

    // Cache used in composer preview
    QImage mCacheImage;

    // Is cache up to date
    bool mCacheUpdated;

    PreviewMode mPreviewMode;

    int mNumCachedLayers;

    bool mDrawing;

    double mXOffset;
    double mYOffset;

    double mMapRotation;

    bool mKeepLayerSet;

    QStringList mLayerSet;

    int mOverviewFrameMapId;
    QgsFillSymbolV2* mOverviewFrameMapSymbol;
    QgsLineSymbolV2* mGridLineSymbol;
    QPainter::CompositionMode mOverviewBlendMode;
    bool mOverviewInverted;
    bool mOverviewCentered;

    void connectUpdateSlot();

    void syncLayerSet();

    bool mGridEnabled;
    GridStyle mGridStyle;
    double mGridIntervalX;
    double mGridIntervalY;
    double mGridOffsetX;
    double mGridOffsetY;
    QFont mGridAnnotationFont;
    QColor mGridAnnotationFontColor;
    int mGridAnnotationPrecision;
    bool mShowGridAnnotation;
    QPainter::CompositionMode mGridBlendMode;

    GridAnnotationPosition mLeftGridAnnotationPosition;
    GridAnnotationPosition mRightGridAnnotationPosition;
    GridAnnotationPosition mTopGridAnnotationPosition;
    GridAnnotationPosition mBottomGridAnnotationPosition;

    double mAnnotationFrameDistance;

    GridAnnotationDirection mLeftGridAnnotationDirection;
    GridAnnotationDirection mRightGridAnnotationDirection;
    GridAnnotationDirection mTopGridAnnotationDirection;
    GridAnnotationDirection mBottomGridAnnotationDirection;

    GridAnnotationFormat mGridAnnotationFormat;

    GridFrameStyle mGridFrameStyle;
    double mGridFrameWidth;
    double mGridFramePenThickness;
    QColor mGridFramePenColor;
    QColor mGridFrameFillColor1;
    QColor mGridFrameFillColor2;

    QRectF mCurrentRectangle;
    double mCrossLength;
    QGraphicsView* mMapCanvas;
    bool mDrawCanvasItems;

    void adjustExtentToItemShape( double itemWidth, double itemHeight, QgsRectangle& extent ) const;

    bool mAtlasDriven;
    bool mAtlasFixedScale;
    double mAtlasMargin;

    QStringList layersToRender();

    void drawGrid( QPainter* p );
    void drawGridFrame( QPainter* p, const QList< QPair< double, QLineF > >& hLines, const QList< QPair< double, QLineF > >& vLines );
    void drawCoordinateAnnotations( QPainter* p, const QList< QPair< double, QLineF > >& hLines, const QList< QPair< double, QLineF > >& vLines );
    void drawCoordinateAnnotation( QPainter* p, const QPointF& pos, QString annotationString );
    void drawAnnotation( QPainter* p, const QPointF& pos, int rotation, const QString& annotationText );
    QString gridAnnotationString( double value, AnnotationCoordinate coord ) const;
    int xGridLines( QList< QPair< double, QLineF > >& lines ) const;
    int yGridLines( QList< QPair< double, QLineF > >& lines ) const;
    QgsRectangle transformedExtent() const;
    QPolygonF transformedMapPolygon() const;
    double maxExtension() const;
    void mapPolygon( QPolygonF& poly ) const;
    void mapPolygon( const QgsRectangle& extent, QPolygonF& poly ) const;

    void requestedExtent( QgsRectangle& extent ) const;
    void transformShift( double& xShift, double& yShift ) const;
    QPointF mapToItemCoords( const QPointF& mapCoords ) const;
    Border borderForLineCoord( const QPointF& p ) const;

    void drawCanvasItems( QPainter* painter, const QStyleOptionGraphicsItem* itemStyle );
    void drawCanvasItem( QGraphicsItem* item, QPainter* painter, const QStyleOptionGraphicsItem* itemStyle );
    QPointF composerMapPosForItem( const QGraphicsItem* item ) 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, Border border );
    void drawGridLine( const QLineF& line, QPainter* p );
    void drawOverviewMapExtent( QPainter* p );
    void createDefaultOverviewFrameSymbol();
    void createDefaultGridLineSymbol();
    void initGridAnnotationFormatFromProject();

};

#endif