src/core/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"

class QDomDocument;
class QDomNode;
class QPainter;

class QgsMapToPixel;
class QgsMapLayer;
class QgsMapRenderer;
class QgsScaleCalculator;
class QgsCoordinateReferenceSystem;
class QgsDistanceArea;
class QgsOverlayObjectPositionManager;
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, 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 ), upsideDown( upside_down ), isDiagram( diagram ), isPinned( pinned ) {}
    QgsLabelPosition(): featureId( -1 ), rotation( 0 ), labelRect( QgsRectangle() ), width( 0 ), height( 0 ), layerID( "" ), labelText( "" ), upsideDown( false ), isDiagram( false ), isPinned( false ) {}
    int featureId;
    double rotation;
    QVector< QgsPoint > cornerPoints;
    QgsRectangle labelRect;
    double width;
    double height;
    QString layerID;
    QString labelText;
    bool upsideDown;
    bool isDiagram;
    bool isPinned;
};

class CORE_EXPORT QgsLabelingEngineInterface
{
  public:

    virtual ~QgsLabelingEngineInterface() {}

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

    virtual QgsLabelingEngineInterface* clone() = 0;
};



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
    };

    QgsMapRenderer();

    ~QgsMapRenderer();

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

    bool setExtent( const QgsRectangle& extent );

    QgsRectangle extent() 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 mSize.width(); };
    int height() const { return 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 );

    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( const QgsMapRenderer::BlendMode blendMode );
    static QgsMapRenderer::BlendMode getBlendModeEnum( const QPainter::CompositionMode blendMode );

  signals:

    void drawingProgress( int current, int total );

    void hasCrsTransformEnabled( bool flag );

    void destinationSrsChanged();

    void updateMap();

    void mapUnitsChanged();

    void drawError( QgsMapLayer* );

  public slots:

    void onDrawingProgress( int current, int total );

  protected:

    void adjustExtentToSize();

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

    QgsOverlayObjectPositionManager* overlayManagerFromSettings();

    static bool mDrawing;

    double mMapUnitsPerPixel;

    double mScale;

    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;

  private:
    const QgsCoordinateTransform* tr( QgsMapLayer *layer );
};

#endif