qgslayoutitem.h

Go to the documentation of this file.

/***************************************************************************
                              qgslayoutitem.h
                             -------------------
    begin                : June 2017
    copyright            : (C) 2017 by Nyall Dawson
    email                : nyall dot dawson 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 QGSLAYOUTITEM_H
#define QGSLAYOUTITEM_H
 
#include "qgis_core.h"
#include "qgslayoutobject.h"
#include "qgslayoutsize.h"
#include "qgslayoutpoint.h"
#include "qgsrendercontext.h"
#include "qgslayoutundocommand.h"
#include "qgslayoutmeasurement.h"
#include "qgsapplication.h"
#include <QGraphicsRectItem>
#include <QIcon>
#include <QPainter>
 
class QgsLayout;
class QPainter;
class QgsLayoutItemGroup;
class QgsLayoutEffect;
class QgsStyleEntityVisitorInterface;
 
class CORE_EXPORT QgsLayoutItemRenderContext
{
  public:
 
    QgsLayoutItemRenderContext( QgsRenderContext &context, double viewScaleFactor = 1.0 );
 
    QgsLayoutItemRenderContext( const QgsLayoutItemRenderContext &other ) = delete;
 
    QgsLayoutItemRenderContext &operator=( const QgsLayoutItemRenderContext &other ) = delete;
 
    QgsRenderContext &renderContext() { return mRenderContext; }
 
    const QgsRenderContext &renderContext() const { return mRenderContext; } SIP_SKIP
 
    double viewScaleFactor() const { return mViewScaleFactor; }
 
  private:
 
#ifdef SIP_RUN
    QgsLayoutItemRenderContext( const QgsLayoutItemRenderContext &rh ) SIP_FORCE;
#endif
 
    QgsRenderContext &mRenderContext;
    double mViewScaleFactor = 1.0;
};
 
class CORE_EXPORT QgsLayoutItem : public QgsLayoutObject, public QGraphicsRectItem, public QgsLayoutUndoObjectInterface
{
#ifdef SIP_RUN
#include "qgslayoutitemgroup.h"
#include "qgslayoutitemmap.h"
#include "qgslayoutitempicture.h"
#include "qgslayoutitemlabel.h"
#include "qgslayoutitemlegend.h"
#include "qgslayoutitempolygon.h"
#include "qgslayoutitempolyline.h"
#include "qgslayoutitemscalebar.h"
#include "qgslayoutframe.h"
#include "qgslayoutitemshape.h"
#include "qgslayoutitempage.h"
#endif
 
#ifdef SIP_RUN
    SIP_CONVERT_TO_SUBCLASS_CODE
 
    // FREAKKKKIIN IMPORTANT!!!!!!!!!!!
    // IF YOU PUT SOMETHING HERE, PUT IT IN QgsLayoutObject CASTING *****ALSO******
    // (it's not enough for it to be in only one of the places, as sip inconsistently
    // decides which casting code to perform here)
 
    // the conversions have to be static, because they're using multiple inheritance
    // (seen in PyQt4 .sip files for some QGraphicsItem classes)
    switch ( sipCpp->type() )
    {
      // really, these *should* use the constants from QgsLayoutItemRegistry, but sip doesn't like that!
      case QGraphicsItem::UserType + 101:
        sipType = sipType_QgsLayoutItemGroup;
        *sipCppRet = static_cast<QgsLayoutItemGroup *>( sipCpp );
        break;
      case QGraphicsItem::UserType + 102:
        sipType = sipType_QgsLayoutItemPage;
        *sipCppRet = static_cast<QgsLayoutItemPage *>( sipCpp );
        break;
      case QGraphicsItem::UserType + 103:
        sipType = sipType_QgsLayoutItemMap;
        *sipCppRet = static_cast<QgsLayoutItemMap *>( sipCpp );
        break;
      case QGraphicsItem::UserType + 104:
        sipType = sipType_QgsLayoutItemPicture;
        *sipCppRet = static_cast<QgsLayoutItemPicture *>( sipCpp );
        break;
      case QGraphicsItem::UserType + 105:
        sipType = sipType_QgsLayoutItemLabel;
        *sipCppRet = static_cast<QgsLayoutItemLabel *>( sipCpp );
        break;
      case QGraphicsItem::UserType + 106:
        sipType = sipType_QgsLayoutItemLegend;
        *sipCppRet = static_cast<QgsLayoutItemLegend *>( sipCpp );
        break;
      case QGraphicsItem::UserType + 107:
        sipType = sipType_QgsLayoutItemShape;
        *sipCppRet = static_cast<QgsLayoutItemShape *>( sipCpp );
        break;
      case QGraphicsItem::UserType + 108:
        sipType = sipType_QgsLayoutItemPolygon;
        *sipCppRet = static_cast<QgsLayoutItemPolygon *>( sipCpp );
        break;
      case QGraphicsItem::UserType + 109:
        sipType = sipType_QgsLayoutItemPolyline;
        *sipCppRet = static_cast<QgsLayoutItemPolyline *>( sipCpp );
        break;
      case QGraphicsItem::UserType + 110:
        sipType = sipType_QgsLayoutItemScaleBar;
        *sipCppRet = static_cast<QgsLayoutItemScaleBar *>( sipCpp );
        break;
      case QGraphicsItem::UserType + 111:
        sipType = sipType_QgsLayoutFrame;
        *sipCppRet = static_cast<QgsLayoutFrame *>( sipCpp );
        break;
 
      // did you read that comment above? NO? Go read it now. You're about to break stuff.
 
      default:
        sipType = NULL;
    }
    SIP_END
#endif
 
 
    Q_OBJECT
    Q_PROPERTY( bool locked READ isLocked WRITE setLocked NOTIFY lockChanged )
 
  public:
 
    enum ReferencePoint
    {
      UpperLeft, 
      UpperMiddle, 
      UpperRight, 
      MiddleLeft, 
      Middle, 
      MiddleRight, 
      LowerLeft, 
      LowerMiddle, 
      LowerRight, 
    };
 
    enum UndoCommand
    {
      UndoNone = -1, 
      UndoIncrementalMove = 1, 
      UndoIncrementalResize, 
      UndoStrokeColor, 
      UndoStrokeWidth, 
      UndoBackgroundColor, 
      UndoOpacity, 
      UndoSetId, 
      UndoRotation, 
      UndoShapeStyle, 
      UndoShapeCornerRadius, 
      UndoNodeMove, 
      UndoAtlasMargin, 
      UndoMapRotation, 
      UndoZoomContent, 
      UndoOverviewStyle, 
      UndoGridFramePenColor, 
      UndoMapGridFrameFill1Color, 
      UndoMapGridFrameFill2Color, 
      UndoMapAnnotationDistance, 
      UndoMapGridAnnotationFontColor, 
      UndoMapGridLineSymbol, 
      UndoMapGridMarkerSymbol, 
      UndoMapGridIntervalRange, 
      UndoMapLabelMargin, 
      UndoPictureRotation, 
      UndoPictureFillColor, 
      UndoPictureStrokeColor, 
      UndoPictureStrokeWidth, 
      UndoPictureNorthOffset, 
      UndoLabelText, 
      UndoLabelFont, 
      UndoLabelMargin, 
      UndoLabelFontColor, 
      UndoLegendText, 
      UndoLegendColumnCount, 
      UndoLegendSymbolWidth, 
      UndoLegendSymbolHeight, 
      UndoLegendMaxSymbolSize, 
      UndoLegendMinSymbolSize, 
      UndoLegendWmsLegendWidth, 
      UndoLegendWmsLegendHeight, 
      UndoLegendTitleSpaceBottom, 
      UndoLegendGroupSpace, 
      UndoLegendGroupIndent, 
      UndoLegendSubgroupIndent, 
      UndoLegendLayerSpace, 
      UndoLegendSymbolSpace, 
      UndoLegendIconSymbolSpace, 
      UndoLegendFontColor, 
      UndoLegendBoxSpace, 
      UndoLegendColumnSpace, 
      UndoLegendLineSpacing, 
      UndoLegendRasterStrokeWidth, 
      UndoLegendRasterStrokeColor, 
      UndoLegendTitleFont, 
      UndoLegendGroupFont, 
      UndoLegendLayerFont, 
      UndoLegendItemFont, 
      UndoScaleBarLineWidth, 
      UndoScaleBarSegmentSize, 
      UndoScaleBarSegmentsLeft, 
      UndoScaleBarSegments, 
      UndoScaleBarHeight, 
      UndoScaleBarSubdivisions, 
      UndoScaleBarSubdivisionsHeight, 
      UndoScaleBarFontColor, 
      UndoScaleBarFillColor, 
      UndoScaleBarFillColor2, 
      UndoScaleBarStrokeColor, 
      UndoScaleBarUnitText, 
      UndoScaleBarMapUnitsSegment, 
      UndoScaleBarLabelBarSize, 
      UndoScaleBarBoxContentSpace, 
      UndoArrowStrokeWidth, 
      UndoArrowHeadWidth, 
      UndoArrowHeadFillColor, 
      UndoArrowHeadStrokeColor, 
 
      UndoCustomCommand, 
    };
 
    enum Flag
    {
      FlagOverridesPaint = 1 << 1,  
      FlagProvidesClipPath = 1 << 2, 
    };
    Q_DECLARE_FLAGS( Flags, Flag )
 
    
    explicit QgsLayoutItem( QgsLayout *layout, bool manageZValue = true );
 
    ~QgsLayoutItem() override;
 
    virtual void cleanup();
 
    int type() const override;
 
    virtual QIcon icon() const { return QgsApplication::getThemeIcon( QStringLiteral( "/mLayoutItem.svg" ) ); }
 
    virtual QString uuid() const { return mUuid; }
 
    virtual Flags itemFlags() const;
 
    QString id() const { return mId; }
 
    virtual void setId( const QString &id );
 
    virtual QString displayName() const;
 
    virtual void setSelected( bool selected );
 
    virtual void setVisibility( bool visible );
 
    void setLocked( bool locked );
 
    bool isLocked() const { return mIsLocked; }
 
    bool isGroupMember() const;
 
    QgsLayoutItemGroup *parentGroup() const;
 
    void setParentGroup( QgsLayoutItemGroup *group );
 
    enum ExportLayerBehavior
    {
      CanGroupWithAnyOtherItem, 
      CanGroupWithItemsOfSameType, 
      MustPlaceInOwnLayer, 
      ItemContainsSubLayers, 
    };
 
    virtual ExportLayerBehavior exportLayerBehavior() const;
 
    Q_DECL_DEPRECATED virtual int numberExportLayers() const SIP_DEPRECATED;
 
    virtual void startLayeredExport();
 
    virtual void stopLayeredExport();
 
    virtual bool nextExportPart();
 
    struct CORE_EXPORT ExportLayerDetail
    {
      QString name;
 
      QString mapLayerId;
 
      QPainter::CompositionMode compositionMode = QPainter::CompositionMode_SourceOver;
 
      double opacity = 1.0;
 
      QString mapTheme;
    };
 
    virtual QgsLayoutItem::ExportLayerDetail exportLayerDetails() const;
 
    void paint( QPainter *painter, const QStyleOptionGraphicsItem *itemStyle, QWidget *pWidget ) override;
 
    void setReferencePoint( ReferencePoint point );
 
    ReferencePoint referencePoint() const { return mReferencePoint; }
 
    virtual QgsLayoutSize fixedSize() const { return mFixedSize; }
 
    virtual QgsLayoutSize minimumSize() const { return mMinimumSize; }
 
    virtual void attemptResize( const QgsLayoutSize &size, bool includesFrame = false );
 
    virtual void attemptMove( const QgsLayoutPoint &point, bool useReferencePoint = true, bool includesFrame = false, int page = -1 );
 
    void attemptSetSceneRect( const QRectF &rect, bool includesFrame = false );
 
    void attemptMoveBy( double deltaX, double deltaY );
 
    QgsLayoutPoint positionWithUnits() const { return mItemPosition; }
 
    int page() const;
 
    QPointF pagePos() const;
 
    QgsLayoutPoint pagePositionWithUnits() const;
 
    QgsLayoutSize sizeWithUnits() const { return mItemSize; }
 
    double itemRotation() const;
 
    bool writeXml( QDomElement &parentElement, QDomDocument &document, const QgsReadWriteContext &context ) const;
 
    bool readXml( const QDomElement &itemElement, const QDomDocument &document, const QgsReadWriteContext &context );
 
    virtual void finalizeRestoreFromXml();
 
    QgsAbstractLayoutUndoCommand *createCommand( const QString &text, int id, QUndoCommand *parent = nullptr ) override SIP_FACTORY;
 
    bool frameEnabled() const { return mFrame; }
 
    virtual void setFrameEnabled( bool drawFrame );
 
    void setFrameStrokeColor( const QColor &color );
 
    QColor frameStrokeColor() const { return mFrameColor; }
 
    virtual void setFrameStrokeWidth( QgsLayoutMeasurement width );
 
    QgsLayoutMeasurement frameStrokeWidth() const { return mFrameWidth; }
 
    Qt::PenJoinStyle frameJoinStyle() const { return mFrameJoinStyle; }
 
    void setFrameJoinStyle( Qt::PenJoinStyle style );
 
    bool hasBackground() const { return mBackground; }
 
    void setBackgroundEnabled( bool drawBackground );
 
    QColor backgroundColor( bool useDataDefined = true ) const;
 
    void setBackgroundColor( const QColor &color );
 
    QPainter::CompositionMode blendMode() const { return mBlendMode; }
 
    void setBlendMode( QPainter::CompositionMode mode );
 
    double itemOpacity() const { return mOpacity; }
 
    void setItemOpacity( double opacity );
 
    bool excludeFromExports() const;
 
    void setExcludeFromExports( bool exclude );
 
    virtual bool containsAdvancedEffects() const;
 
    virtual bool requiresRasterization() const;
 
    virtual double estimatedFrameBleed() const;
 
    virtual QRectF rectWithFrame() const;
 
    virtual void moveContent( double dx, double dy );
 
    virtual void setMoveContentPreviewOffset( double dx, double dy );
 
    virtual void zoomContent( double factor, QPointF point );
 
    void beginCommand( const QString &commandText, UndoCommand command = UndoNone );
 
    void endCommand();
 
    void cancelCommand();
 
    bool shouldDrawItem() const;
 
    QgsExpressionContext createExpressionContext() const override;
 
    virtual bool accept( QgsStyleEntityVisitorInterface *visitor ) const;
 
    virtual QgsGeometry clipPath() const;
 
  public slots:
 
    void refresh() override;
 
    virtual void invalidateCache();
 
    virtual void redraw();
 
    virtual void refreshDataDefinedProperty( QgsLayoutObject::DataDefinedProperty property = QgsLayoutObject::AllProperties );
 
    virtual void setItemRotation( double rotation, bool adjustPosition = true );
 
    virtual void rotateItem( double angle, QPointF transformOrigin );
 
  signals:
 
    void frameChanged();
 
    void lockChanged();
 
    void rotationChanged( double newRotation );
 
    void sizePositionChanged();
 
    void backgroundTaskCountChanged( int count );
 
    void clipPathChanged();
 
  protected:
 
    virtual void drawDebugRect( QPainter *painter );
 
    virtual void draw( QgsLayoutItemRenderContext &context ) = 0;
 
    virtual QPainterPath framePath() const;
 
    virtual void drawFrame( QgsRenderContext &context );
 
    virtual void drawBackground( QgsRenderContext &context );
 
    virtual void setFixedSize( const QgsLayoutSize &size );
 
    virtual void setMinimumSize( const QgsLayoutSize &size );
 
    virtual QSizeF applyItemSizeConstraint( QSizeF targetSize );
 
    void refreshItemSize();
 
    void refreshItemPosition();
 
    void refreshItemRotation( QPointF *origin = nullptr );
 
    void refreshOpacity( bool updateItem = true );
 
    void refreshFrame( bool updateItem = true );
 
    void refreshBackgroundColor( bool updateItem = true );
 
    void refreshBlendMode();
 
    QPointF adjustPointForReferencePosition( QPointF point, QSizeF size, ReferencePoint reference ) const;
 
    QPointF positionAtReferencePoint( ReferencePoint reference ) const;
 
    QgsLayoutPoint topLeftToReferencePoint( const QgsLayoutPoint &point ) const;
 
    virtual bool writePropertiesToElement( QDomElement &element, QDomDocument &document, const QgsReadWriteContext &context ) const;
 
    virtual bool readPropertiesFromElement( const QDomElement &element, const QDomDocument &document, const QgsReadWriteContext &context );
 
    QgsLayoutSize applyDataDefinedSize( const QgsLayoutSize &size );
 
  private:
 
    // true if layout manages the z value for this item
    bool mLayoutManagesZValue = false;
 
    QString mId;
 
    QString mUuid;
 
    QString mTemplateUuid;
 
    QString mParentGroupUuid;
 
    ReferencePoint mReferencePoint = UpperLeft;
    QgsLayoutSize mFixedSize;
    QgsLayoutSize mMinimumSize;
 
    QgsLayoutSize mItemSize;
    QgsLayoutPoint mItemPosition;
    double mItemRotation = 0.0;
 
    bool mExcludeFromExports = false;
 
    bool mEvaluatedExcludeFromExports = false;
 
    QPainter::CompositionMode mBlendMode = QPainter::CompositionMode_SourceOver;
    QPointer< QgsLayoutEffect > mEffect;
 
    double mOpacity = 1.0;
    double mEvaluatedOpacity = 1.0;
 
    QImage mItemCachedImage;
    double mItemCacheDpi = -1;
 
    bool mIsLocked = false;
 
    bool mFrame = false;
    QColor mFrameColor = QColor( 0, 0, 0 );
    QgsLayoutMeasurement mFrameWidth = QgsLayoutMeasurement( 0.3, QgsUnitTypes::LayoutMillimeters );
    Qt::PenJoinStyle mFrameJoinStyle = Qt::MiterJoin;
 
    bool mBackground = true;
    QColor mBackgroundColor = QColor( 255, 255, 255 );
 
    bool mBlockUndoCommands = false;
 
    void initConnectionsToLayout();
 
    void preparePainter( QPainter *painter );
    bool shouldDrawAntialiased() const;
    bool shouldDrawDebugRect() const;
    QSizeF applyMinimumSize( QSizeF targetSize );
    QSizeF applyFixedSize( QSizeF targetSize );
    QgsLayoutPoint applyDataDefinedPosition( const QgsLayoutPoint &position );
 
    double applyDataDefinedRotation( double rotation );
    void updateStoredItemPosition();
    QPointF itemPositionAtReferencePoint( ReferencePoint reference, QSizeF size ) const;
    void setScenePos( QPointF destinationPos );
    bool shouldBlockUndoCommands() const;
 
    void applyDataDefinedOrientation( double &width, double &height, const QgsExpressionContext &context );
 
    friend class TestQgsLayoutItem;
    friend class TestQgsLayoutView;
    friend class QgsLayout;
    friend class QgsLayoutItemGroup;
    friend class QgsCompositionConverter;
};
 
Q_DECLARE_OPERATORS_FOR_FLAGS( QgsLayoutItem::Flags )
 
#endif //QGSLAYOUTITEM_H