qgscomposeritem.h

Go to the documentation of this file.

/***************************************************************************
                         qgscomposeritem.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 QGSCOMPOSERITEM_H
#define QGSCOMPOSERITEM_H

#include "qgscomposeritemcommand.h"
#include "qgscomposereffect.h"
#include "qgscomposerobject.h"
#include "qgsmaprenderer.h" // for blend mode functions & enums
#include <QGraphicsRectItem>
#include <QObject>

class QWidget;
class QDomDocument;
class QDomElement;
class QGraphicsLineItem;
class QgsComposerItemGroup;
class QgsDataDefined;
class QgsComposition;

class CORE_EXPORT QgsComposerItem: public QgsComposerObject, public QGraphicsRectItem
{
    Q_OBJECT
  public:

    enum ItemType
    {
      // base class for the items
      ComposerItem = UserType + 100,

      // derived classes
      ComposerArrow,
      ComposerItemGroup,
      ComposerLabel,
      ComposerLegend,
      ComposerMap,
      ComposerPaper, // QgsPaperItem
      ComposerPicture,
      ComposerScaleBar,
      ComposerShape,
      ComposerTable,
      ComposerAttributeTable,
      ComposerTextTable,
      ComposerFrame
    };

    enum MouseMoveAction
    {
      MoveItem,
      ResizeUp,
      ResizeDown,
      ResizeLeft,
      ResizeRight,
      ResizeLeftUp,
      ResizeRightUp,
      ResizeLeftDown,
      ResizeRightDown,
      NoAction
    };

    enum ItemPositionMode
    {
      UpperLeft,
      UpperMiddle,
      UpperRight,
      MiddleLeft,
      Middle,
      MiddleRight,
      LowerLeft,
      LowerMiddle,
      LowerRight
    };

    //note - must sync with QgsMapCanvas::WheelAction.
    //TODO - QGIS 3.0 move QgsMapCanvas::WheelAction from GUI->CORE and remove this enum
    enum ZoomMode
    {
      Zoom = 0, /*< Zoom to center of content */
      ZoomRecenter, /*< Zoom and recenter content to point */
      ZoomToPoint, /*< Zoom while maintaining relative position of point */
      NoZoom /*< No zoom */
    };

    QgsComposerItem( QgsComposition* composition, bool manageZValue = true );
    QgsComposerItem( qreal x, qreal y, qreal width, qreal height, QgsComposition* composition, bool manageZValue = true );
    virtual ~QgsComposerItem();

    virtual int type() const { return ComposerItem; }

    virtual bool isRemoved() const { return mRemovedFromComposition; }

    void setIsRemoved( const bool removed ) { mRemovedFromComposition = removed; }

    virtual void setSelected( bool s );

    virtual bool selected() const { return QGraphicsRectItem::isSelected(); }

    void move( double dx, double dy );

    virtual void moveContent( double dx, double dy ) { Q_UNUSED( dx ); Q_UNUSED( dy ); }

    Q_DECL_DEPRECATED virtual void zoomContent( int delta, double x, double y ) { Q_UNUSED( delta ); Q_UNUSED( x ); Q_UNUSED( y ); }

    virtual void zoomContent( const double factor, const QPointF point, const ZoomMode mode = QgsComposerItem::Zoom ) { Q_UNUSED( factor ); Q_UNUSED( point ); Q_UNUSED( mode ); }

    int page() const;

    QPointF pagePos() const;

    void updatePagePos( double newPageWidth, double newPageHeight );

    void setItemPosition( double x, double y, ItemPositionMode itemPoint = UpperLeft, int page = -1 );

    void setItemPosition( double x, double y, double width, double height, ItemPositionMode itemPoint = UpperLeft, bool posIncludesFrame = false, int page = -1 );

    ItemPositionMode lastUsedPositionMode() { return mLastUsedPositionMode; }

    virtual void setSceneRect( const QRectF& rectangle );

    bool _writeXML( QDomElement& itemElem, QDomDocument& doc ) const;

    bool _readXML( const QDomElement& itemElem, const QDomDocument& doc );

    bool hasFrame() const {return mFrame;}

    void setFrameEnabled( const bool drawFrame );

    virtual void setFrameOutlineColor( const QColor& color );

    QColor frameOutlineColor() const { return pen().color(); }

    virtual void setFrameOutlineWidth( const double outlineWidth );

    double frameOutlineWidth() const { return pen().widthF(); }

    Qt::PenJoinStyle frameJoinStyle() const { return mFrameJoinStyle; }

    void setFrameJoinStyle( const Qt::PenJoinStyle style );

    virtual double estimatedFrameBleed() const;

    virtual QRectF rectWithFrame() const;

    bool hasBackground() const {return mBackground;}

    void setBackgroundEnabled( const bool drawBackground ) { mBackground = drawBackground; }

    QColor backgroundColor() const { return mBackgroundColor; }

    void setBackgroundColor( const QColor& backgroundColor );

    QPainter::CompositionMode blendMode() const { return mBlendMode; }

    void setBlendMode( const QPainter::CompositionMode blendMode );

    int transparency() const { return mTransparency; }

    void setTransparency( const int transparency );

    bool effectsEnabled() const { return mEffectsEnabled; }

    void setEffectsEnabled( const bool effectsEnabled );

    virtual void addItem( QgsComposerItem* item ) { Q_UNUSED( item ); }
    virtual void removeItems() {}

    virtual void beginItemCommand( const QString& text ) { beginCommand( text ); }

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

    virtual void endItemCommand() { endCommand(); }
    void endCommand();
    void cancelCommand();

    //functions that encapsulate the workaround for the Qt font bug (that is to scale the font size up and then scale the
    //painter down by the same factor for drawing

    Q_DECL_DEPRECATED void drawText( QPainter* p, double x, double y, const QString& text, const QFont& font, const QColor& c = QColor() ) const;

    Q_DECL_DEPRECATED void drawText( QPainter* p, const QRectF& rect, const QString& text, const QFont& font, Qt::AlignmentFlag halignment = Qt::AlignLeft, Qt::AlignmentFlag valignment = Qt::AlignTop, int flags = Qt::TextWordWrap ) const;

    Q_DECL_DEPRECATED double textWidthMillimeters( const QFont& font, const QString& text ) const;

    Q_DECL_DEPRECATED double fontHeightCharacterMM( const QFont& font, const QChar& c ) const;

    Q_DECL_DEPRECATED double fontAscentMillimeters( const QFont& font ) const;

    Q_DECL_DEPRECATED double fontDescentMillimeters( const QFont& font ) const;

    Q_DECL_DEPRECATED double fontHeightMillimeters( const QFont& font ) const;

    Q_DECL_DEPRECATED double pixelFontSize( double pointSize ) const;

    Q_DECL_DEPRECATED QFont scaledFontPixelSize( const QFont& font ) const;

    void setPositionLock( const bool lock );

    bool positionLock() const { return mItemPositionLocked; }

    double itemRotation( const QgsComposerObject::PropertyValueType valueType = QgsComposerObject::EvaluatedValue ) const;

    Q_DECL_DEPRECATED double rotation() const { return mEvaluatedItemRotation; }

    virtual void updateItem() { QGraphicsRectItem::update(); }

    QString id() const { return mId; }

    virtual void setId( const QString& id );

    QString uuid() const { return mUuid; }

    virtual QString displayName() const;

    virtual void setVisibility( const bool visible );

    bool excludeFromExports( const QgsComposerObject::PropertyValueType valueType = QgsComposerObject::EvaluatedValue );

    virtual void setExcludeFromExports( const bool exclude );

    bool isGroupMember() const { return mIsGroupMember; }

    void setIsGroupMember( const bool isGroupMember );

    virtual int numberExportLayers() const { return 0; }

    virtual void setCurrentExportLayer( const int layerIdx = -1 ) { mCurrentExportLayer = layerIdx; }

  public slots:
    virtual void setRotation( double r );

    virtual void setItemRotation( const double r, const bool adjustPosition = false );

    void repaint();

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

  protected:
    bool mRemovedFromComposition;

    QgsComposerItem::MouseMoveAction mCurrentMouseMoveAction;
    QPointF mMouseMoveStartPos;
    QPointF mLastMouseEventPos;

    QGraphicsRectItem* mBoundingResizeRectangle;
    QGraphicsLineItem* mHAlignSnapItem;
    QGraphicsLineItem* mVAlignSnapItem;

    bool mFrame;
    bool mBackground;
    QColor mBackgroundColor;
    Qt::PenJoinStyle mFrameJoinStyle;

    bool mItemPositionLocked;

    mutable double mLastValidViewScaleFactor;

    double mItemRotation;
    double mEvaluatedItemRotation;

    QPainter::CompositionMode mBlendMode;
    bool mEffectsEnabled;
    QgsComposerEffect *mEffect;

    int mTransparency;

    bool mExcludeFromExports;

    bool mEvaluatedExcludeFromExports;

    ItemPositionMode mLastUsedPositionMode;

    bool mIsGroupMember;

    int mCurrentExportLayer;

    virtual void drawSelectionBoxes( QPainter* p );

    virtual void drawFrame( QPainter* p );

    virtual void drawBackground( QPainter* p );

    Q_DECL_DEPRECATED void drawArrowHead( QPainter* p, double x, double y, double angle, double arrowHeadWidth ) const;

    Q_DECL_DEPRECATED double angle( const QPointF& p1, const QPointF& p2 ) const;

    double rectHandlerBorderTolerance() const;

    Q_DECL_DEPRECATED double lockSymbolSize() const;

    double horizontalViewScaleFactor() const;

    //some utility functions

    Q_DECL_DEPRECATED bool imageSizeConsideringRotation( double& width, double& height, double rotation ) const;

    Q_DECL_DEPRECATED bool imageSizeConsideringRotation( double& width, double& height ) const;

    Q_DECL_DEPRECATED QRectF largestRotatedRectWithinBounds( QRectF originalRect, QRectF boundsRect, double rotation ) const;

    Q_DECL_DEPRECATED bool cornerPointOnRotatedAndScaledRect( double& x, double& y, double width, double height, double rotation ) const;

    Q_DECL_DEPRECATED bool cornerPointOnRotatedAndScaledRect( double& x, double& y, double width, double height ) const;

    Q_DECL_DEPRECATED void sizeChangedByRotation( double& width, double& height, double rotation );

    Q_DECL_DEPRECATED void sizeChangedByRotation( double& width, double& height );

    Q_DECL_DEPRECATED void rotate( double angle, double& x, double& y ) const;

    QGraphicsLineItem* hAlignSnapItem();
    void deleteHAlignSnapItem();
    QGraphicsLineItem* vAlignSnapItem();
    void deleteVAlignSnapItem();
    void deleteAlignItems();

    QRectF evalItemRect( const QRectF &newRect, const bool resizeOnly = false );

    bool shouldDrawItem() const;

  signals:
    void itemRotationChanged( double newRotation );
    void sizeChanged();
    void frameChanged();
    void lockChanged();

  private:
    // id (not unique)
    QString mId;
    // name (unique)
    QString mUuid;
    // name (temporary when loaded from template)
    QString mTemplateUuid;
    // true if composition manages the z value for this item
    bool mCompositionManagesZValue;

    void refreshRotation( const bool updateItem = true, const bool rotateAroundCenter = false );

    void refreshTransparency( const bool updateItem = true );

    void refreshBlendMode();

    void init( const bool manageZValue );

    friend class QgsComposerItemGroup; // to access mTemplateUuid
};

#endif