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 <QGraphicsRectItem>
#include <QIcon>
#include <QPainter>

class QgsLayout;
class QPainter;
class QgsLayoutItemGroup;
class QgsLayoutEffect;


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
    // 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;
      default:
        sipType = 0;
    }
    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, 
      UndoPictureRotation, 
      UndoPictureFillColor, 
      UndoPictureStrokeColor, 
      UndoPictureStrokeWidth, 
      UndoPictureNorthOffset, 
      UndoLabelText, 
      UndoLabelFont, 
      UndoLabelMargin, 
      UndoLabelFontColor, 
      UndoLegendText, 
      UndoLegendColumnCount, 
      UndoLegendSymbolWidth, 
      UndoLegendSymbolHeight, 
      UndoLegendWmsLegendWidth, 
      UndoLegendWmsLegendHeight, 
      UndoLegendTitleSpaceBottom, 
      UndoLegendGroupSpace, 
      UndoLegendLayerSpace, 
      UndoLegendSymbolSpace, 
      UndoLegendIconSymbolSpace, 
      UndoLegendFontColor, 
      UndoLegendBoxSpace, 
      UndoLegendColumnSpace, 
      UndoLegendLineSpacing, 
      UndoLegendRasterStrokeWidth, 
      UndoLegendRasterStrokeColor, 
      UndoLegendTitleFont, 
      UndoLegendGroupFont, 
      UndoLegendLayerFont, 
      UndoLegendItemFont, 
      UndoScaleBarLineWidth, 
      UndoScaleBarSegmentSize, 
      UndoScaleBarSegmentsLeft, 
      UndoScaleBarSegments, 
      UndoScaleBarHeight, 
      UndoScaleBarFontColor, 
      UndoScaleBarFillColor, 
      UndoScaleBarFillColor2, 
      UndoScaleBarStrokeColor, 
      UndoScaleBarUnitText, 
      UndoScaleBarMapUnitsSegment, 
      UndoScaleBarLabelBarSize, 
      UndoScaleBarBoxContentSpace, 
      UndoArrowStrokeWidth, 
      UndoArrowHeadWidth, 
      UndoArrowHeadFillColor, 
      UndoArrowHeadStrokeColor, 

      UndoCustomCommand, 
    };

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

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

    virtual int numberExportLayers() const { return 0; }

    void paint( QPainter *painter, const QStyleOptionGraphicsItem *itemStyle, QWidget *pWidget ) override;

    void setReferencePoint( const 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( const 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() const { return mBackgroundColor; }

    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;

  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, const QPointF &transformOrigin );

  signals:

    void frameChanged();

    void lockChanged();

    void rotationChanged( double newRotation );

    void sizePositionChanged();

  protected:

    virtual void drawDebugRect( QPainter *painter );

    virtual void draw( QgsLayoutItemRenderContext &context ) = 0;

    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( const 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( const QPointF &point, const QSizeF &size, const ReferencePoint &reference ) const;

    QPointF positionAtReferencePoint( const 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;
    std::unique_ptr< QgsLayoutEffect > mEffect;

    double mOpacity = 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( const QSizeF &targetSize );
    QSizeF applyFixedSize( const QSizeF &targetSize );
    QgsLayoutPoint applyDataDefinedPosition( const QgsLayoutPoint &position );

    double applyDataDefinedRotation( double rotation );
    void updateStoredItemPosition();
    QPointF itemPositionAtReferencePoint( ReferencePoint reference, const QSizeF &size ) const;
    void setScenePos( const 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;
};

#endif //QGSLAYOUTITEM_H