qgsmaprendererjob.h

Go to the documentation of this file.

/***************************************************************************
  qgsmaprendererjob.h
  --------------------------------------
  Date                 : December 2013
  Copyright            : (C) 2013 by Martin Dobias
  Email                : wonder dot 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 QGSMAPRENDERERJOB_H
#define QGSMAPRENDERERJOB_H

#include "qgis_core.h"
#include "qgis_sip.h"
#include "qgis.h"
#include <QFutureWatcher>
#include <QImage>
#include <QPainter>
#include <QObject>
#include <QTime>

#include "qgsrendercontext.h"

#include "qgsmapsettings.h"


class QgsLabelingEngine;
class QgsLabelingResults;
class QgsMapLayerRenderer;
class QgsMapRendererCache;
class QgsFeatureFilterProvider;

#ifndef SIP_RUN

struct LayerRenderJob
{
  QgsRenderContext context;
  QImage *img; // may be null if it is not necessary to draw to separate image (e.g. sequential rendering)
  bool imageInitialized = false;
  QgsMapLayerRenderer *renderer; // must be deleted
  QPainter::CompositionMode blendMode;
  double opacity;
  bool cached; // if true, img already contains cached image from previous rendering
  QgsWeakMapLayerPointer layer;
  int renderingTime; 
};

typedef QList<LayerRenderJob> LayerRenderJobs;

struct LabelRenderJob
{
  QgsRenderContext context;

  QImage *img = nullptr;
  bool cached = false;
  bool canUseCache = false;
  bool complete = false;
  int renderingTime = -1;
  QList< QPointer< QgsMapLayer > > participatingLayers;
};

#endif

class CORE_EXPORT QgsMapRendererJob : public QObject
{
    Q_OBJECT
  public:

    QgsMapRendererJob( const QgsMapSettings &settings );

    virtual void start() = 0;

    virtual void cancel() = 0;

    virtual void cancelWithoutBlocking() = 0;

    virtual void waitForFinished() = 0;

    virtual bool isActive() const = 0;

    virtual bool usedCachedLabels() const = 0;

    virtual QgsLabelingResults *takeLabelingResults() = 0 SIP_TRANSFER;

    void setFeatureFilterProvider( const QgsFeatureFilterProvider *f ) { mFeatureFilterProvider = f; }

    const QgsFeatureFilterProvider *featureFilterProvider() const { return mFeatureFilterProvider; }

    struct Error
    {
      Error( const QString &lid, const QString &msg )
        : layerID( lid )
        , message( msg )
      {}

      QString layerID;
      QString message;
    };

    typedef QList<QgsMapRendererJob::Error> Errors;

    Errors errors() const;


    void setCache( QgsMapRendererCache *cache );

    int renderingTime() const { return mRenderingTime; }

    QHash< QgsMapLayer *, int > perLayerRenderingTime() const SIP_SKIP;

    const QgsMapSettings &mapSettings() const;

    static const QString LABEL_CACHE_ID SIP_SKIP;

  signals:

    void renderingLayersFinished();

    void finished();

  protected:

    QgsMapSettings mSettings;
    QTime mRenderingStart;
    Errors mErrors;

    QgsMapRendererCache *mCache = nullptr;

    int mRenderingTime = 0;

    QHash< QgsWeakMapLayerPointer, int > mPerLayerRenderingTime;

    bool prepareLabelCache() const SIP_SKIP;

    LayerRenderJobs prepareJobs( QPainter *painter, QgsLabelingEngine *labelingEngine2 ) SIP_SKIP;

    LabelRenderJob prepareLabelingJob( QPainter *painter, QgsLabelingEngine *labelingEngine2, bool canUseLabelCache = true ) SIP_SKIP;

    static QImage composeImage( const QgsMapSettings &settings, const LayerRenderJobs &jobs, const LabelRenderJob &labelJob ) SIP_SKIP;

    void logRenderingTime( const LayerRenderJobs &jobs, const LabelRenderJob &labelJob ) SIP_SKIP;

    void cleanupJobs( LayerRenderJobs &jobs ) SIP_SKIP;

    void cleanupLabelJob( LabelRenderJob &job ) SIP_SKIP;

    static void drawLabeling( const QgsMapSettings &settings, QgsRenderContext &renderContext, QgsLabelingEngine *labelingEngine2, QPainter *painter ) SIP_SKIP;

  private:

    static bool reprojectToLayerExtent( const QgsMapLayer *ml, const QgsCoordinateTransform &ct, QgsRectangle &extent, QgsRectangle &r2 );

    bool needTemporaryImage( QgsMapLayer *ml );

    const QgsFeatureFilterProvider *mFeatureFilterProvider = nullptr;
};


class CORE_EXPORT QgsMapRendererQImageJob : public QgsMapRendererJob
{
    Q_OBJECT

  public:
    QgsMapRendererQImageJob( const QgsMapSettings &settings );

    virtual QImage renderedImage() = 0;

};


#endif // QGSMAPRENDERERJOB_H