qgsmaprenderer.h

Go to the documentation of this file.

/***************************************************************************
    qgsmaprender.h  -  class for rendering map layer set
    ----------------------
    begin                : January 2006
    copyright            : (C) 2006 by Martin Dobias
    email                : wonder.sk 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.                                   *
 *                                                                         *
 ***************************************************************************/

#ifndef QGSMAPRENDER_H
#define QGSMAPRENDER_H

#include <QMutex>
#include <QSize>
#include <QStringList>
#include <QVector>
#include <QPainter>

#include "qgis.h"
#include "qgsrectangle.h"
#include "qgsrendercontext.h"
#include "qgsfeature.h"
#include "qgsmapsettings.h"

class QDomDocument;
class QDomNode;
class QPainter;

class QgsMapToPixel;
class QgsMapLayer;
class QgsMapRenderer;
class QgsScaleCalculator;
class QgsCoordinateReferenceSystem;
class QgsDistanceArea;
class QgsVectorLayer;

class QgsPalLayerSettings;
class QgsDiagramLayerSettings;

class CORE_EXPORT QgsLabelPosition
{
  public:
    QgsLabelPosition( int id, double r, const QVector< QgsPoint >& corners, const QgsRectangle& rect, double w, double h, const QString& layer, const QString& labeltext, const QFont& labelfont, bool upside_down, bool diagram = false, bool pinned = false )
        : featureId( id ), rotation( r ), cornerPoints( corners ), labelRect( rect ), width( w ), height( h ), layerID( layer ), labelText( labeltext ), labelFont( labelfont ), upsideDown( upside_down ), isDiagram( diagram ), isPinned( pinned ) {}
    QgsLabelPosition()
        : featureId( -1 ), rotation( 0 ), labelRect( QgsRectangle() ), width( 0 ), height( 0 ), layerID( "" ), labelText( "" ), labelFont( QFont() ), upsideDown( false ), isDiagram( false ), isPinned( false ) {}
    int featureId;
    double rotation;
    QVector< QgsPoint > cornerPoints;
    QgsRectangle labelRect;
    double width;
    double height;
    QString layerID;
    QString labelText;
    QFont labelFont;
    bool upsideDown;
    bool isDiagram;
    bool isPinned;
};

class CORE_EXPORT QgsLabelingEngineInterface
{
  public:

    virtual ~QgsLabelingEngineInterface() {}

    Q_DECL_DEPRECATED virtual void init( QgsMapRenderer *mp ) = 0;
    virtual void init( const QgsMapSettings& mapSettings ) = 0;
    virtual bool willUseLayer( QgsVectorLayer* layer ) = 0;
    virtual void clearActiveLayers() = 0;
    virtual void clearActiveLayer( const QString& layerID ) = 0;
    virtual int prepareLayer( QgsVectorLayer* layer, QStringList& attrNames, QgsRenderContext& ctx ) = 0;
    Q_DECL_DEPRECATED virtual QgsPalLayerSettings &layer( const QString &layerName ) = 0;
    virtual int prepareDiagramLayer( QgsVectorLayer *layer, QStringList &attrNames, QgsRenderContext &ctx )
    { Q_UNUSED( layer ); Q_UNUSED( attrNames ); Q_UNUSED( ctx ); return 0; }
    Q_DECL_DEPRECATED virtual int addDiagramLayer( QgsVectorLayer *layer, const QgsDiagramLayerSettings *s )
    { Q_UNUSED( layer ); Q_UNUSED( s ); return 0; }
    virtual void registerFeature( const QString &layerID, QgsFeature &feat, QgsRenderContext &context ) = 0;
    virtual void registerDiagramFeature( const QString &layerID, QgsFeature &feat, QgsRenderContext &context )
    { Q_UNUSED( layerID ); Q_UNUSED( feat ); Q_UNUSED( context ); }
    virtual void drawLabeling( QgsRenderContext& context ) = 0;
    virtual void exit() = 0;
    Q_DECL_DEPRECATED virtual QList<QgsLabelPosition> labelsAtPosition( const QgsPoint& p ) = 0;
    Q_DECL_DEPRECATED virtual QList<QgsLabelPosition> labelsWithinRect( const QgsRectangle& r ) = 0;

    virtual QgsLabelingEngineInterface* clone() = 0;
};

struct CORE_EXPORT QgsLayerCoordinateTransform
{
  QString srcAuthId;
  QString destAuthId;
  int srcDatumTransform; //-1 if unknown or not specified
  int destDatumTransform;
};

// ### QGIS 3: remove QgsMapRenderer in favor of QgsMapRendererJob

class CORE_EXPORT QgsMapRenderer : public QObject
{
    Q_OBJECT

  public:

    enum OutputUnits
    {
      Millimeters,
      Pixels
      //MAP_UNITS probably supported in future versions
    };

    enum BlendMode
    {
      BlendNormal,
      BlendLighten,
      BlendScreen,
      BlendDodge,
      BlendAddition,
      BlendDarken,
      BlendMultiply,
      BlendBurn,
      BlendOverlay,
      BlendSoftLight,
      BlendHardLight,
      BlendDifference,
      BlendSubtract,
      BlendSource,
      BlendDestinationOver,
      BlendClear,
      BlendDestination,
      BlendSourceIn,
      BlendDestinationIn,
      BlendSourceOut,
      BlendDestinationOut,
      BlendSourceAtop,
      BlendDestinationAtop,
      BlendXor,
    };

    QgsMapRenderer();

    ~QgsMapRenderer();

    void render( QPainter* painter, double* forceWidthScale = nullptr );

    bool setExtent( const QgsRectangle& extent );

    QgsRectangle extent() const;

    void setRotation( double degrees );

    double rotation() const;

    const QgsMapToPixel* coordinateTransform() { return &( mRenderContext.mapToPixel() ); }

    double scale() const { return mScale; }
    void setScale( double scale ) {mScale = scale;}
    double mapUnitsPerPixel() const { return mMapUnitsPerPixel; }

    int width() const { return static_cast< int >( mSize.width() ); }
    int height() const { return static_cast< int >( mSize.height() ); }

    void updateScale();

    QGis::UnitType mapUnits() const;
    void setMapUnits( QGis::UnitType u );

    void enableOverviewMode( bool isOverview = true ) { mOverview = isOverview; }

    void setOutputSize( QSize size, int dpi );
    void setOutputSize( QSizeF size, double dpi );

    double outputDpi();
    QSize outputSize();
    QSizeF outputSizeF();

    QgsRectangle layerExtentToOutputExtent( QgsMapLayer* theLayer, QgsRectangle extent );

    QgsRectangle outputExtentToLayerExtent( QgsMapLayer* theLayer, QgsRectangle extent );

    QgsPoint layerToMapCoordinates( QgsMapLayer* theLayer, QgsPoint point );

    QgsRectangle layerToMapCoordinates( QgsMapLayer* theLayer, QgsRectangle rect );

    QgsPoint mapToLayerCoordinates( QgsMapLayer* theLayer, QgsPoint point );

    QgsRectangle mapToLayerCoordinates( QgsMapLayer* theLayer, QgsRectangle rect );

    void setProjectionsEnabled( bool enabled );

    bool hasCrsTransformEnabled() const;

    void setDestinationCrs( const QgsCoordinateReferenceSystem& crs, bool refreshCoordinateTransformInfo = true, bool transformExtent = true );

    const QgsCoordinateReferenceSystem& destinationCrs() const;

    void setOutputUnits( OutputUnits u ) {mOutputUnits = u;}

    OutputUnits outputUnits() const {return mOutputUnits;}

    QgsRectangle fullExtent();

    QStringList& layerSet();

    void setLayerSet( const QStringList& layers );

    void updateFullExtent();

    bool readXML( QDomNode & theNode );

    bool writeXML( QDomNode & theNode, QDomDocument & theDoc );

    QgsRenderContext* rendererContext() {return &mRenderContext;}

    QgsLabelingEngineInterface* labelingEngine() { return mLabelingEngine; }

    void setLabelingEngine( QgsLabelingEngineInterface* iface );

    static QPainter::CompositionMode getCompositionMode( BlendMode blendMode );
    static QgsMapRenderer::BlendMode getBlendModeEnum( QPainter::CompositionMode blendMode );

    void addLayerCoordinateTransform( const QString& layerId, const QString& srcAuthId, const QString& destAuthId, int srcDatumTransform = -1, int destDatumTransform = -1 );
    void clearLayerCoordinateTransforms();

    const QgsCoordinateTransform* transformation( const QgsMapLayer *layer ) const;

    const QgsMapSettings& mapSettings();

    bool splitLayersExtent( QgsMapLayer* layer, QgsRectangle& extent, QgsRectangle& r2 );

    void setFeatureFilterProvider( const QgsFeatureFilterProvider* ffp )
    {
      mRenderContext.setFeatureFilterProvider( ffp );
    }

  signals:

    void drawingProgress( int current, int total );

#ifndef Q_MOC_RUN
    Q_DECL_DEPRECATED
#endif
    void hasCrsTransformEnabled( bool flag );

    void hasCrsTransformEnabledChanged( bool flag );

    void destinationSrsChanged();

    void updateMap();

    void mapUnitsChanged();

    void drawError( QgsMapLayer* );

    void extentsChanged();

    void rotationChanged( double );

    void datumTransformInfoRequested( const QgsMapLayer* ml, const QString& srcAuthId, const QString& destAuthId ) const;


  public slots:

    Q_DECL_DEPRECATED void onDrawingProgress( int current, int total );

  protected:

    void adjustExtentToSize();

    static bool mDrawing;

    double mMapUnitsPerPixel;

    double mScale;

    double mRotation;

    QgsScaleCalculator * mScaleCalculator;

    QgsRectangle mExtent;
    //
    QgsRectangle mLastExtent;

    bool mOverview;

    QSizeF mSize;

    bool mProjectionsEnabled;

    QgsCoordinateReferenceSystem* mDestCRS;

    QStringList mLayerSet;

    QgsRectangle mFullExtent;

    QgsDistanceArea* mDistArea;

    QgsRenderContext mRenderContext;

    OutputUnits mOutputUnits;

    QgsLabelingEngineInterface* mLabelingEngine;

    QMutex mRenderMutex;

    QgsMapSettings mMapSettings;

    QHash< QString, QgsLayerCoordinateTransform > mLayerCoordinateTransformInfo;
};

#endif