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 "qgsmaprenderer.h" // for blend mode functions & enums
#include <QGraphicsRectItem>
#include <QObject>

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

class CORE_EXPORT QgsComposerItem: public QObject, 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
    };

    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 void setSelected( bool s );

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

    virtual bool writeSettings();

    virtual bool readSettings();

    virtual bool removeSettings();

    void move( double dx, double dy );

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

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

    void setItemPosition( double x, double y, ItemPositionMode itemPoint = UpperLeft );

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

    ItemPositionMode lastUsedPositionMode() { return mLastUsedPositionMode; }

    virtual void setSceneRect( const QRectF& rectangle );

    virtual bool writeXML( QDomElement& elem, QDomDocument & doc ) const = 0;

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

    virtual bool readXML( const QDomElement& itemElem, const QDomDocument& doc ) = 0;

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

    bool hasFrame() const {return mFrame;}

    void setFrameEnabled( bool drawFrame );

    virtual void setFrameOutlineWidth( double outlineWidth );

    virtual double estimatedFrameBleed() const;

    virtual QRectF rectWithFrame() const;

    bool hasBackground() const {return mBackground;}

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

    QColor backgroundColor() const { return mBackgroundColor; }

    void setBackgroundColor( const QColor& backgroundColor );

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

    void setBlendMode( QPainter::CompositionMode blendMode );

    int transparency() const {return mTransparency;}
    void setTransparency( int transparency );

    bool effectsEnabled() const {return mEffectsEnabled;}
    void setEffectsEnabled( bool effectsEnabled );

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

    const QgsComposition* composition() const {return mComposition;}
    QgsComposition* composition() {return mComposition;}

    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

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

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

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

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

    double fontAscentMillimeters( const QFont& font ) const;

    double fontDescentMillimeters( const QFont& font ) const;

    double pixelFontSize( double pointSize ) const;

    QFont scaledFontPixelSize( const QFont& font ) const;

    void setPositionLock( bool lock );

    bool positionLock() const {return mItemPositionLocked;}

    double itemRotation() const {return mItemRotation;}

    double rotation() const {return mItemRotation;}

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

    QString id() const { return mId; }

    virtual void setId( const QString& id );

    QString uuid() const { return mUuid; }

  public slots:
    virtual void setRotation( double r );

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

    void repaint();

  protected:

    QgsComposition* mComposition;

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

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

    bool mFrame;
    bool mBackground;
    QColor mBackgroundColor;

    bool mItemPositionLocked;

    mutable double mLastValidViewScaleFactor;

    double mItemRotation;

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

    int mTransparency;

    ItemPositionMode mLastUsedPositionMode;

    virtual void drawSelectionBoxes( QPainter* p );

    virtual void drawFrame( QPainter* p );

    virtual void drawBackground( QPainter* p );

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

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

    double rectHandlerBorderTolerance() const;

    double lockSymbolSize() const;

    double horizontalViewScaleFactor() const;

    //some utility functions

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

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

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

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

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

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

  signals:
    void itemRotationChanged( double newRotation );
    void itemChanged();
    void sizeChanged();
    void frameChanged();
  private:
    // id (not unique)
    QString mId;
    // name (unique)
    QString mUuid;
    // name (temporary when loaded from template)
    QString mTemplateUuid;

    void init( bool manageZValue );

    friend class QgsComposerItemGroup; // to access mTemplateUuid
};

#endif