qgscomposition.h

Go to the documentation of this file.

/***************************************************************************
                              qgscomposition.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 QGSCOMPOSITION_H
#define QGSCOMPOSITION_H

#include <memory>

#include <QDomDocument>
#include <QGraphicsScene>
#include <QLinkedList>
#include <QList>
#include <QPair>
#include <QSet>
#include <QUndoStack>
#include <QPrinter>
#include <QPainter>

#include "qgsaddremoveitemcommand.h"
#include "qgscomposeritemcommand.h"
#include "qgscomposermultiframecommand.h"
#include "qgsatlascomposition.h"
#include "qgspaperitem.h"
#include "qgscomposerobject.h"
#include "qgscomposeritem.h"

class QgisApp;
class QgsComposerFrame;
class QgsComposerMap;
class QGraphicsRectItem;
class QgsMapRenderer;
class QDomElement;
class QgsComposerArrow;
class QgsComposerMouseHandles;
class QgsComposerHtml;
class QgsComposerTableV2;
class QgsComposerItem;
class QgsComposerItemGroup;
class QgsComposerLabel;
class QgsComposerLegend;
class QgsComposerMap;
class QgsComposerPicture;
class QgsComposerScaleBar;
class QgsComposerShape;
class QgsComposerAttributeTable;
class QgsComposerAttributeTableV2;
class QgsComposerMultiFrame;
class QgsComposerMultiFrameCommand;
class QgsVectorLayer;
class QgsComposer;
class QgsFillSymbolV2;
class QgsDataDefined;
class QgsComposerModel;

class CORE_EXPORT QgsComposition : public QGraphicsScene
{
    Q_OBJECT
  public:

    enum PlotStyle
    {
      Preview = 0, // Use cache etc
      Print,       // Render well
      Postscript   // Fonts need different scaling!
    };

    enum GridStyle
    {
      Solid,
      Dots,
      Crosses
    };

    enum ZValueDirection
    {
      ZValueBelow,
      ZValueAbove
    };

    enum PaperOrientation
    {
      Portrait,
      Landscape
    };

    Q_DECL_DEPRECATED QgsComposition( QgsMapRenderer* mapRenderer );
    explicit QgsComposition( const QgsMapSettings& mapSettings );

    enum AtlasMode
    {
      AtlasOff,     // Composition is not being controlled by an atlas
      PreviewAtlas, // An atlas composition is being previewed in the app
      ExportAtlas   // The composition is being exported as an atlas
    };

    ~QgsComposition();

    void setPaperSize( const double width, const double height );

    double paperHeight() const;

    double paperWidth() const;

    double spaceBetweenPages() const { return mSpaceBetweenPages; }

    void setNumPages( const int pages );

    int numPages() const;

    bool pageIsEmpty( const int page ) const;

    bool shouldExportPage( const int page ) const;

    void setPageStyleSymbol( QgsFillSymbolV2* symbol );
    QgsFillSymbolV2* pageStyleSymbol() { return mPageStyleSymbol; }

    QPointF positionOnPage( const QPointF & position ) const;

    int pageNumberForPoint( const QPointF & position ) const;

    void setStatusMessage( const QString & message );

    void updateSettings();

    void setSnapToGridEnabled( const bool b );
    bool snapToGridEnabled() const {return mSnapToGrid;}

    void setGridVisible( const bool b );
    bool gridVisible() const {return mGridVisible;}

    void setSnapLinesVisible( const bool visible );
    bool snapLinesVisible() const {return mGuidesVisible;}

    void setAlignmentSnap( const bool s ) { mAlignmentSnap = s; }
    bool alignmentSnap() const { return mAlignmentSnap; }

    void setSmartGuidesEnabled( const bool b ) { mSmartGuides = b; }
    bool smartGuidesEnabled() const {return mSmartGuides;}

    void clearSnapLines();

    void setSnapGridResolution( const double r );
    double snapGridResolution() const {return mSnapGridResolution;}

    void setSnapGridOffsetX( const double offset );
    double snapGridOffsetX() const {return mSnapGridOffsetX;}

    void setSnapGridOffsetY( const double offset );
    double snapGridOffsetY() const {return mSnapGridOffsetY;}

    void setGridPen( const QPen& p );
    const QPen& gridPen() const {return mGridPen;}

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

    Q_DECL_DEPRECATED void setSnapGridTolerance( double tolerance ) { mSnapTolerance = tolerance; }

    Q_DECL_DEPRECATED double snapGridTolerance() const {return mSnapTolerance;}

    Q_DECL_DEPRECATED void setAlignmentSnapTolerance( double t ) { mSnapTolerance = t; }

    Q_DECL_DEPRECATED double alignmentSnapTolerance() const { return mSnapTolerance; }

    void setSnapTolerance( const int snapTolerance ) { mSnapTolerance = snapTolerance; }

    int snapTolerance() const { return mSnapTolerance; }

    QUndoStack* undoStack() { return mUndoStack; }

    QgsComposerItem* composerItemAt( const QPointF & position, const bool ignoreLocked = false ) const;

    QgsComposerItem* composerItemAt( const QPointF & position, const QgsComposerItem* belowItem, const bool ignoreLocked = false ) const;

    int pageNumberAt( const QPointF& position ) const;

    int itemPageNumber( const QgsComposerItem* ) const;

    QList<QgsComposerItem*> selectedComposerItems( const bool includeLockedItems = true );

    QList<const QgsComposerMap*> composerMapItems() const;

    template<class T> void composerItems( QList<T*>& itemList );

    template<class T> void composerItemsOnPage( QList<T*>& itemList, const int pageNumber ) const;

    const QgsComposerMap* getComposerMapById( const int id ) const;

    Q_DECL_DEPRECATED const QgsComposerHtml* getComposerHtmlByItem( QgsComposerItem *item ) const;

    const QgsComposerItem* getComposerItemById( const QString theId ) const;

    const QgsComposerItem* getComposerItemByUuid( const QString theUuid ) const;

    int printResolution() const {return mPrintResolution;}
    void setPrintResolution( const int dpi );

    bool printAsRaster() const {return mPrintAsRaster;}
    void setPrintAsRaster( const bool enabled ) { mPrintAsRaster = enabled; }

    bool generateWorldFile() const { return mGenerateWorldFile; }
    void setGenerateWorldFile( const bool enabled ) { mGenerateWorldFile = enabled; }

    QgsComposerMap* worldFileMap() const { return mWorldFileMap; }
    void setWorldFileMap( QgsComposerMap* map ) { mWorldFileMap = map; }

    bool useAdvancedEffects() const {return mUseAdvancedEffects;}
    void setUseAdvancedEffects( const bool effectsEnabled );


    Q_DECL_DEPRECATED QgsMapRenderer* mapRenderer() {return mMapRenderer;}

    const QgsMapSettings& mapSettings() const { return mMapSettings; }

    QgsComposition::PlotStyle plotStyle() const {return mPlotStyle;}
    void setPlotStyle( const QgsComposition::PlotStyle style ) {mPlotStyle = style;}

    Q_DECL_DEPRECATED int pixelFontSize( double pointSize ) const;

    Q_DECL_DEPRECATED double pointFontSize( int pixelSize ) const;

    bool writeXML( QDomElement& composerElem, QDomDocument& doc );

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

    bool loadFromTemplate( const QDomDocument& doc, QMap<QString, QString>* substitutionMap = 0,
                           bool addUndoCommands = false, const bool clearComposition = true );

    void addItemsFromXML( const QDomElement& elem, const QDomDocument& doc, QMap< QgsComposerMap*, int >* mapsToRestore = 0,
                          bool addUndoCommands = false, QPointF* pos = 0, bool pasteInPlace = false );

    void addItemToZList( QgsComposerItem* item );
    void removeItemFromZList( QgsComposerItem* item );

    //functions to move selected items in hierarchy
    void raiseSelectedItems();

    //returns true if successful
    bool raiseItem( QgsComposerItem* item );
    void lowerSelectedItems();
    //returns true if successful
    bool lowerItem( QgsComposerItem* item );
    void moveSelectedItemsToTop();
    //returns true if successful
    bool moveItemToTop( QgsComposerItem* item );
    void moveSelectedItemsToBottom();
    //returns true if successful
    bool moveItemToBottom( QgsComposerItem* item );

    //functions to find items by their position in the z list
    void selectNextByZOrder( const ZValueDirection direction );
    QgsComposerItem* getComposerItemBelow( QgsComposerItem* item ) const;
    QgsComposerItem* getComposerItemAbove( QgsComposerItem* item ) const;

    //functions to align selected items
    void alignSelectedItemsLeft();
    void alignSelectedItemsHCenter();
    void alignSelectedItemsRight();
    void alignSelectedItemsTop();
    void alignSelectedItemsVCenter();
    void alignSelectedItemsBottom();

    //functions to lock and unlock items
    void lockSelectedItems();
    void unlockAllItems();

    QgsComposerItemGroup* groupItems( QList<QgsComposerItem*> items );

    QList<QgsComposerItem*> ungroupItems( QgsComposerItemGroup* group );

    Q_DECL_DEPRECATED void sortZList() {};

    void refreshZList();

    QPointF snapPointToGrid( const QPointF& scenePoint ) const;

    QList< QGraphicsLineItem* >* snapLines() {return &mSnapLines;}

    QgsComposerMouseHandles* selectionHandles() {return mSelectionHandles;}

    QGraphicsLineItem* addSnapLine();
    void removeSnapLine( QGraphicsLineItem* line );
    QGraphicsLineItem* nearestSnapLine( const bool horizontal, const double x, const double y, const double tolerance, QList< QPair< QgsComposerItem*, QgsComposerItem::ItemPositionMode > >& snappedItems ) const;

    void beginCommand( QgsComposerItem* item, const QString& commandText, const QgsComposerMergeCommand::Context c = QgsComposerMergeCommand::Unknown );

    void endCommand();
    void cancelCommand();

    void beginMultiFrameCommand( QgsComposerMultiFrame* multiFrame, const QString& text, const QgsComposerMultiFrameMergeCommand::Context c = QgsComposerMultiFrameMergeCommand::Unknown );
    void endMultiFrameCommand();
    void cancelMultiFrameCommand();

    void addMultiFrame( QgsComposerMultiFrame* multiFrame );
    void removeMultiFrame( QgsComposerMultiFrame* multiFrame );
    void addComposerArrow( QgsComposerArrow* arrow );
    void addComposerLabel( QgsComposerLabel* label );
    void addComposerMap( QgsComposerMap* map, const bool setDefaultPreviewStyle = true );
    void addComposerScaleBar( QgsComposerScaleBar* scaleBar );
    void addComposerLegend( QgsComposerLegend* legend );
    void addComposerPicture( QgsComposerPicture* picture );
    void addComposerShape( QgsComposerShape* shape );
    void addComposerTable( QgsComposerAttributeTable* table );
    void addComposerHtmlFrame( QgsComposerHtml* html, QgsComposerFrame* frame );
    void addComposerTableFrame( QgsComposerAttributeTableV2* table, QgsComposerFrame* frame );

    void removeComposerItem( QgsComposerItem* item, const bool createCommand = true, const bool removeGroupItems = true );

    void pushAddRemoveCommand( QgsComposerItem* item, const QString& text, const QgsAddRemoveItemCommand::State state = QgsAddRemoveItemCommand::Added );

    void setPreventCursorChange( const bool preventChange ) { mPreventCursorChange = preventChange; }
    bool preventCursorChange() const { return mPreventCursorChange; }

    //printing

    void beginPrint( QPrinter& printer, const bool evaluateDDPageSize = false );
    void beginPrintAsPDF( QPrinter& printer, const QString& file );

    void doPrint( QPrinter& printer, QPainter& painter, bool startNewPage = false );

    bool print( QPrinter &printer, const bool evaluateDDPageSize = false );

    bool exportAsPDF( const QString& file );

    QImage printPageAsRaster( int page );

    void renderPage( QPainter* p, int page );

    void computeWorldFileParameters( double& a, double& b, double& c, double& d, double& e, double& f ) const;

    QgsAtlasComposition& atlasComposition() { return mAtlasComposition; }

    Q_DECL_DEPRECATED static void relativeResizeRect( QRectF& rectToResize, const QRectF& boundsBefore, const QRectF& boundsAfter );

    Q_DECL_DEPRECATED static double relativePosition( double position, double beforeMin, double beforeMax, double afterMin, double afterMax );

    QgsComposition::AtlasMode atlasMode() const { return mAtlasMode; }

    bool setAtlasMode( const QgsComposition::AtlasMode mode );

    QList< QgsPaperItem* > pages() { return mPages; }

    QgsDataDefined* dataDefinedProperty( const QgsComposerObject::DataDefinedProperty property );

    void setDataDefinedProperty( const QgsComposerObject::DataDefinedProperty property, bool active, bool useExpression, const QString &expression, const QString &field );

    QgsComposerModel * itemsModel() { return mItemsModel; }

  public slots:
    void sendItemAddedSignal( QgsComposerItem* item );

    void updateBounds();

    void refreshItems();

    void setSelectedItem( QgsComposerItem* item );

    void setAllUnselected();

    void refreshDataDefinedProperty( const QgsComposerObject::DataDefinedProperty property = QgsComposerObject::AllProperties );

  protected:
    void init();


  private:
    QgsMapRenderer* mMapRenderer;
    const QgsMapSettings& mMapSettings;

    QgsComposition::PlotStyle mPlotStyle;
    double mPageWidth;
    double mPageHeight;
    QList< QgsPaperItem* > mPages;
    double mSpaceBetweenPages; //space in preview between pages

    QgsFillSymbolV2* mPageStyleSymbol;
    void createDefaultPageStyleSymbol();

    QSet<QgsComposerMultiFrame*> mMultiFrames;

    int mPrintResolution;

    bool mPrintAsRaster;

    bool mGenerateWorldFile;
    QgsComposerMap* mWorldFileMap;

    bool mUseAdvancedEffects;

    bool mSnapToGrid;
    bool mGridVisible;
    double mSnapGridResolution;
    double mSnapGridOffsetX;
    double mSnapGridOffsetY;
    QPen mGridPen;
    GridStyle mGridStyle;

    bool mAlignmentSnap;
    bool mGuidesVisible;
    bool mSmartGuides;
    int mSnapTolerance;

    QList< QGraphicsLineItem* > mSnapLines;

    QgsComposerMouseHandles* mSelectionHandles;

    QUndoStack* mUndoStack;

    QgsComposerItemCommand* mActiveItemCommand;
    QgsComposerMultiFrameCommand* mActiveMultiFrameCommand;

    QgsAtlasComposition mAtlasComposition;

    QgsComposition::AtlasMode mAtlasMode;

    bool mPreventCursorChange;

    QgsComposerModel * mItemsModel;

    QMap< QgsComposerObject::DataDefinedProperty, QString > mDataDefinedNames;
    QMap< QgsComposerObject::DataDefinedProperty, QgsDataDefined* > mDataDefinedProperties;

    QgsComposition(); //default constructor is forbidden

    QRectF compositionBounds() const;

    void updateZValues( const bool addUndoCommands = true );

    int boundingRectOfSelectedItems( QRectF& bRect );

    void loadDefaults();

    void loadSettings();

    QPointF minPointFromXml( const QDomElement& elem ) const;

    void connectAddRemoveCommandSignals( QgsAddRemoveItemCommand* c );

    void updatePaperItems();
    void addPaperItem();
    void removePaperItems();
    void deleteAndRemoveMultiFrames();

    static QString encodeStringForXML( const QString& str );

    //tries to return the current QGraphicsView attached to the composition
    QGraphicsView* graphicsView() const;

    /*Recalculates the page size using data defined page settings*/
    void refreshPageSize();

    bool dataDefinedEvaluate( QgsComposerObject::DataDefinedProperty property, QVariant &expressionValue,
                              QMap< QgsComposerObject::DataDefinedProperty, QgsDataDefined* >* dataDefinedProperties );

    bool dataDefinedActive( const QgsComposerObject::DataDefinedProperty property,
                            const QMap<QgsComposerObject::DataDefinedProperty, QgsDataDefined *> *dataDefinedProperties ) const;

    QVariant dataDefinedValue( QgsComposerObject::DataDefinedProperty property, const QgsFeature *feature, const QgsFields *fields,
                               QMap<QgsComposerObject::DataDefinedProperty, QgsDataDefined *> *dataDefinedProperties ) const;


    void prepareDataDefinedExpression( QgsDataDefined *dd, QMap< QgsComposerObject::DataDefinedProperty, QgsDataDefined* >* dataDefinedProperties ) const;

    bool ddPageSizeActive() const;

  private slots:
    /*Prepares all data defined expressions*/
    void prepareAllDataDefinedExpressions();

  signals:
    void paperSizeChanged();
    void nPagesChanged();

    void printResolutionChanged();

    void selectedItemChanged( QgsComposerItem* selected );
    void composerArrowAdded( QgsComposerArrow* arrow );
    void composerHtmlFrameAdded( QgsComposerHtml* html, QgsComposerFrame* frame );
    void composerLabelAdded( QgsComposerLabel* label );
    void composerMapAdded( QgsComposerMap* map );
    void composerScaleBarAdded( QgsComposerScaleBar* scalebar );
    void composerLegendAdded( QgsComposerLegend* legend );
    void composerPictureAdded( QgsComposerPicture* picture );
    void composerShapeAdded( QgsComposerShape* shape );
    void composerTableAdded( QgsComposerAttributeTable* table );
    void composerTableFrameAdded( QgsComposerAttributeTableV2* table, QgsComposerFrame* frame );
    void itemRemoved( QgsComposerItem* );

    void refreshItemsTriggered();

    void statusMsgChanged( QString message );

    friend class QgsComposerObject; //for accessing dataDefinedEvaluate, readDataDefinedPropertyMap and writeDataDefinedPropertyMap
    friend class QgsComposerModel; //for accessing updateZValues (should not be public)
};

template<class T> void QgsComposition::composerItems( QList<T*>& itemList )
{
  itemList.clear();
  QList<QGraphicsItem *> graphicsItemList = items();
  QList<QGraphicsItem *>::iterator itemIt = graphicsItemList.begin();
  for ( ; itemIt != graphicsItemList.end(); ++itemIt )
  {
    T* item = dynamic_cast<T*>( *itemIt );
    if ( item )
    {
      itemList.push_back( item );
    }
  }
}

template<class T> void QgsComposition::composerItemsOnPage( QList<T*>& itemList, const int pageNumber ) const
{
  itemList.clear();
  QList<QGraphicsItem *> graphicsItemList = items();
  QList<QGraphicsItem *>::iterator itemIt = graphicsItemList.begin();
  for ( ; itemIt != graphicsItemList.end(); ++itemIt )
  {
    T* item = dynamic_cast<T*>( *itemIt );
    if ( item && itemPageNumber( item ) == pageNumber )
    {
      itemList.push_back( item );
    }
  }
}


#endif