qgspainteffect.h

Go to the documentation of this file.

/***************************************************************************
                             qgspainteffect.h
                             ----------------
    begin                : December 2014
    copyright            : (C) 2014 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 QGSPAINTEFFECT_H
#define QGSPAINTEFFECT_H
 
#include "qgis.h"
#include "qgis_core.h"
#include "qgis_sip.h"
#include "qgspainting.h"
 
#include <QDomDocument>
#include <QDomElement>
#include <QPainter>
#include <QPicture>
#include <QString>
 
using namespace Qt::StringLiterals;
 
class QgsRenderContext;

 
class CORE_EXPORT QgsPaintEffect SIP_NODEFAULTCTORS
{
#ifdef SIP_RUN
    SIP_CONVERT_TO_SUBCLASS_CODE
    if ( sipCpp->type() == "drawSource" && dynamic_cast<QgsDrawSourceEffect *>( sipCpp ) != NULL )
    {
      sipType = sipType_QgsDrawSourceEffect;
    }
    else if ( sipCpp->type() == "effectStack" && dynamic_cast<QgsEffectStack *>( sipCpp ) != NULL )
    {
      sipType = sipType_QgsEffectStack;
    }
    else if ( sipCpp->type() == "blur" && dynamic_cast<QgsBlurEffect *>( sipCpp ) != NULL )
    {
      sipType = sipType_QgsBlurEffect;
    }
    else if ( sipCpp->type() == "dropShadow" && dynamic_cast<QgsDropShadowEffect *>( sipCpp ) != NULL )
    {
      sipType = sipType_QgsDropShadowEffect;
    }
    else if ( sipCpp->type() == "outerGlow" && dynamic_cast<QgsOuterGlowEffect *>( sipCpp ) != NULL )
    {
      sipType = sipType_QgsOuterGlowEffect;
    }
    else if ( sipCpp->type() == "innerGlow" && dynamic_cast<QgsInnerGlowEffect *>( sipCpp ) != NULL )
    {
      sipType = sipType_QgsInnerGlowEffect;
    }
    else if ( sipCpp->type() == "transform" && dynamic_cast<QgsTransformEffect *>( sipCpp ) != NULL )
    {
      sipType = sipType_QgsTransformEffect;
    }
    else if ( sipCpp->type() == "color" && dynamic_cast<QgsColorEffect *>( sipCpp ) != NULL )
    {
      sipType = sipType_QgsColorEffect;
    }
    else
    {
      sipType = 0;
    }
  SIP_END
#endif
 
  public:
    enum DrawMode
    {
      Modifier,       
      Render,         
      ModifyAndRender 
    };
 
    QgsPaintEffect() = default;
 
    QgsPaintEffect( const QgsPaintEffect &other );
    virtual ~QgsPaintEffect();

    virtual QString type() const = 0;

    virtual QgsPaintEffect *clone() const = 0 SIP_FACTORY;

    virtual Qgis::PaintEffectFlags flags() const;

    virtual QVariantMap properties() const = 0;

    virtual void readProperties( const QVariantMap &props ) = 0;

    virtual bool saveProperties( QDomDocument &doc, QDomElement &element ) const;

    virtual bool readProperties( const QDomElement &element );

    virtual void render( const QPicture &picture, QgsRenderContext &context );

    virtual void begin( QgsRenderContext &context );

    virtual void end( QgsRenderContext &context );

    bool enabled() const { return mEnabled; }

    void setEnabled( bool enabled );

    DrawMode drawMode() const { return mDrawMode; }

    void setDrawMode( DrawMode drawMode );
 
  protected:
    bool mEnabled = true;
    DrawMode mDrawMode = ModifyAndRender;
    bool requiresQPainterDpiFix = true;

    virtual void draw( QgsRenderContext &context ) = 0;

    void drawSource( QPainter &painter );

    const QPicture &source() const { return mPicture; }

    QImage sourceAsImage( QgsRenderContext &context );

    QPointF imageOffset( const QgsRenderContext &context ) const;

    virtual QRectF boundingRect( const QRectF &rect, const QgsRenderContext &context ) const;

    Q_DECL_DEPRECATED void fixQPictureDpi( QPainter *painter ) const SIP_DEPRECATED;
 
  private:
    QPicture mPicture;
    QImage mSourceImage;
 
    QPainter *mPrevPainter = nullptr;
    std::unique_ptr< QPainter > mEffectPainter;
    std::unique_ptr< QPicture > mTempPicture;
 
    QRectF imageBoundingRect( const QgsRenderContext &context ) const;
 
    friend class QgsEffectStack;
 
    QgsPaintEffect &operator=( const QgsPaintEffect & ) = delete;
};

 
class CORE_EXPORT QgsDrawSourceEffect : public QgsPaintEffect SIP_NODEFAULTCTORS
{
  public:
    QgsDrawSourceEffect() = default;

    static std::unique_ptr<QgsPaintEffect> create( const QVariantMap &map );
 
    Qgis::PaintEffectFlags flags() const override;
    QString type() const override { return u"drawSource"_s; }
    QgsDrawSourceEffect *clone() const override SIP_FACTORY;
    QVariantMap properties() const override;
 
    using QgsPaintEffect::readProperties;
    void readProperties( const QVariantMap &props ) override;

    void setOpacity( const double opacity ) { mOpacity = opacity; }

    double opacity() const { return mOpacity; }

    void setBlendMode( const QPainter::CompositionMode mode ) { mBlendMode = mode; }

    QPainter::CompositionMode blendMode() const { return mBlendMode; }
 
  protected:
    void draw( QgsRenderContext &context ) override;
 
  private:
    double mOpacity = 1.0;
    QPainter::CompositionMode mBlendMode = QPainter::CompositionMode_SourceOver;
};

class CORE_EXPORT QgsEffectPainter
{
  public:
    QgsEffectPainter( QgsRenderContext &renderContext );

    QgsEffectPainter( QgsRenderContext &renderContext, QgsPaintEffect *effect );
    ~QgsEffectPainter();
 
    QgsEffectPainter( const QgsEffectPainter & ) = delete;
    QgsEffectPainter &operator=( const QgsEffectPainter & ) = delete;
    QgsEffectPainter( QgsEffectPainter && ) = delete;
    QgsEffectPainter &operator=( QgsEffectPainter && ) = delete;

    void setEffect( QgsPaintEffect *effect );


    QPainter *operator->() { return mPainter; }
 
  private:
#ifdef SIP_RUN
    QgsEffectPainter( const QgsEffectPainter & );
    const QgsEffectPainter &operator=( const QgsEffectPainter & );
#endif
 
    QgsRenderContext &mRenderContext;
    QPainter *mPainter = nullptr;
    QgsScopedQPainterState mPainterState;
    QgsPaintEffect *mEffect = nullptr;
};
 
#endif // QGSPAINTEFFECT_H