qgsatlascomposition.h

Go to the documentation of this file.

/***************************************************************************
                             qgsatlascomposermap.h
                             ---------------------
    begin                : October 2012
    copyright            : (C) 2005 by Hugo Mercier
    email                : hugo dot mercier at oslandia 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 QGSATLASCOMPOSITION_H
#define QGSATLASCOMPOSITION_H

#include "qgscoordinatetransform.h"
#include "qgsfeature.h"

#include <memory>
#include <QString>
#include <QDomElement>
#include <QDomDocument>

class QgsComposerMap;
class QgsComposition;
class QgsVectorLayer;
class QgsExpression;

class CORE_EXPORT QgsAtlasComposition : public QObject
{
    Q_OBJECT
  public:
    QgsAtlasComposition( QgsComposition* composition );
    ~QgsAtlasComposition();

    bool enabled() const { return mEnabled; }

    void setEnabled( bool enabled );

    Q_DECL_DEPRECATED QgsComposerMap* composerMap() const;

    Q_DECL_DEPRECATED void setComposerMap( QgsComposerMap* map );

    bool hideCoverage() const { return mHideCoverage; }

    void setHideCoverage( bool hide );

    Q_DECL_DEPRECATED bool fixedScale() const;

    Q_DECL_DEPRECATED void setFixedScale( bool fixed );

    Q_DECL_DEPRECATED float margin() const;

    Q_DECL_DEPRECATED void setMargin( float margin );

    QString filenamePattern() const { return mFilenamePattern; }

    bool setFilenamePattern( const QString& pattern );

    QString filenamePatternErrorString() const { return mFilenameParserError; }

    QgsVectorLayer* coverageLayer() const { return mCoverageLayer; }

    void setCoverageLayer( QgsVectorLayer* layer );

    bool singleFile() const { return mSingleFile; }

    void setSingleFile( bool single ) { mSingleFile = single; }

    bool sortFeatures() const { return mSortFeatures; }
    void setSortFeatures( bool doSort ) { mSortFeatures = doSort; }

    bool sortAscending() const { return mSortAscending; }
    void setSortAscending( bool ascending ) { mSortAscending = ascending; }

    bool filterFeatures() const { return mFilterFeatures; }
    void setFilterFeatures( bool doFilter ) { mFilterFeatures = doFilter; }

    QString featureFilter() const { return mFeatureFilter; }
    void setFeatureFilter( const QString& expression ) { mFeatureFilter = expression; }

    QString featureFilterErrorString() const { return mFilterParserError; }

    QString sortKeyAttributeName() const { return mSortKeyAttributeName; }
    void setSortKeyAttributeName( QString fieldName ) { mSortKeyAttributeName = fieldName; }

    Q_DECL_DEPRECATED int sortKeyAttributeIndex() const;
    Q_DECL_DEPRECATED void setSortKeyAttributeIndex( int idx );

    const QVector<double>& predefinedScales() const { return mPredefinedScales; }

    void setPredefinedScales( const QVector<double>& scales );

    bool beginRender();
    void endRender();

    int numFeatures() const;

    bool prepareForFeature( int i );

    bool prepareForFeature( QgsFeature * feat );

    const QString& currentFilename() const;

    void writeXML( QDomElement& elem, QDomDocument& doc ) const;
    void readXML( const QDomElement& elem, const QDomDocument& doc );

    QgsComposition* composition() { return mComposition; }

    int updateFeatures();

    void nextFeature();
    void prevFeature();
    void lastFeature();
    void firstFeature();

    QgsFeature* currentFeature() { return &mCurrentFeature; }

    void prepareMap( QgsComposerMap* map );

  signals:
    void parameterChanged();

    void toggled( bool );

    void statusMsgChanged( QString message );

    void coverageLayerChanged( QgsVectorLayer* layer );

    void renderBegun();

    void renderEnded();

    void featureChanged( QgsFeature* feature );

  private:
    bool updateFilenameExpression();

    bool evalFeatureFilename();

    QgsComposition* mComposition;

    bool mEnabled;
    bool mHideCoverage;
    QString mFilenamePattern;
    QgsVectorLayer* mCoverageLayer;
    bool mSingleFile;

    QgsCoordinateTransform mTransform;
    QString mCurrentFilename;
    // feature ordering
    bool mSortFeatures;
    // sort direction
    bool mSortAscending;

    // current atlas feature number
    int mCurrentFeatureNo;

  public:
    typedef QMap< QgsFeatureId, QVariant > SorterKeys;

  private:
    // value of field that is used for ordering of features
    SorterKeys mFeatureKeys;
    // key (attribute index) used for ordering
    QString mSortKeyAttributeName;

    // feature filtering
    bool mFilterFeatures;
    // feature expression filter
    QString mFeatureFilter;

    // id of each iterated feature (after filtering and sorting)
    QVector<QgsFeatureId> mFeatureIds;

    QgsFeature mCurrentFeature;

    std::auto_ptr<QgsExpression> mFilenameExpr;

    // bounding box of the current feature transformed into map crs
    QgsRectangle mTransformedFeatureBounds;

    QString mFilenameParserError;
    QString mFilterParserError;

    //forces all atlas enabled maps to redraw
    void updateAtlasMaps();

    //computes the extent of the current feature, in the crs of the specified map
    void computeExtent( QgsComposerMap *map );

    //list of predefined scales
    QVector<double> mPredefinedScales;
};

#endif