// This file is generated by kconfig_compiler_kf6 from easyeffects_db_reverb.kcfg.
// All changes you do to this file will be lost.
#ifndef DBREVERB_H
#define DBREVERB_H

#include "kconfig_base_ee.hpp"

#include <kconfigskeleton.h>
#include <QCoreApplication>
#include <QDebug>
#include <qqmlintegration.h>

class DbReverb : public KConfigBaseEE
{
  Q_OBJECT
  QML_ELEMENT
  QML_UNCREATABLE("")
  public:

    DbReverb( const QString & masterGroup, const QString & instanceIndex );
    ~DbReverb() override;

    /**
      Set bypass
    */
    void setBypass( bool v )
    {
      if (v != mBypass && !isBypassImmutable()) {
        mBypass = v;
        Q_EMIT bypassChanged();
      }
    }

    Q_PROPERTY(bool bypass READ bypass WRITE setBypass NOTIFY bypassChanged)
    Q_PROPERTY(bool isBypassImmutable READ isBypassImmutable CONSTANT)
    Q_PROPERTY(bool defaultBypassValue READ defaultBypassValue CONSTANT)
    /**
      Get bypass
    */
    bool bypass() const
    {
      return mBypass;
    }

    /**
      Is bypass Immutable
    */
    bool isBypassImmutable() const
    {
      return isImmutable( QStringLiteral( "bypass" ) );
    }

    /**
      Get bypass default value
    */
    bool defaultBypassValue() const
    {
        return defaultBypassValue_helper();
    }

    /**
      Set inputGain
    */
    void setInputGain( double v )
    {
      if (v < -36)
      {
        qDebug() << "setInputGain: value " << v << " is less than the minimum value of -36";
        v = -36;
      }

      if (v > 36)
      {
        qDebug() << "setInputGain: value " << v << " is greater than the maximum value of 36";
        v = 36;
      }

      if (v != mInputGain && !isInputGainImmutable()) {
        mInputGain = v;
        Q_EMIT inputGainChanged();
      }
    }

    Q_PROPERTY(double inputGain READ inputGain WRITE setInputGain NOTIFY inputGainChanged)
    Q_PROPERTY(bool isInputGainImmutable READ isInputGainImmutable CONSTANT)
    Q_PROPERTY(double defaultInputGainValue READ defaultInputGainValue CONSTANT)
    /**
      Get inputGain
    */
    double inputGain() const
    {
      return mInputGain;
    }

    /**
      Is inputGain Immutable
    */
    bool isInputGainImmutable() const
    {
      return isImmutable( QStringLiteral( "inputGain" ) );
    }

    /**
      Get inputGain default value
    */
    double defaultInputGainValue() const
    {
        return defaultInputGainValue_helper();
    }

    /**
      Set outputGain
    */
    void setOutputGain( double v )
    {
      if (v < -36)
      {
        qDebug() << "setOutputGain: value " << v << " is less than the minimum value of -36";
        v = -36;
      }

      if (v > 36)
      {
        qDebug() << "setOutputGain: value " << v << " is greater than the maximum value of 36";
        v = 36;
      }

      if (v != mOutputGain && !isOutputGainImmutable()) {
        mOutputGain = v;
        Q_EMIT outputGainChanged();
      }
    }

    Q_PROPERTY(double outputGain READ outputGain WRITE setOutputGain NOTIFY outputGainChanged)
    Q_PROPERTY(bool isOutputGainImmutable READ isOutputGainImmutable CONSTANT)
    Q_PROPERTY(double defaultOutputGainValue READ defaultOutputGainValue CONSTANT)
    /**
      Get outputGain
    */
    double outputGain() const
    {
      return mOutputGain;
    }

    /**
      Is outputGain Immutable
    */
    bool isOutputGainImmutable() const
    {
      return isImmutable( QStringLiteral( "outputGain" ) );
    }

    /**
      Get outputGain default value
    */
    double defaultOutputGainValue() const
    {
        return defaultOutputGainValue_helper();
    }

    /**
      Set roomSizeLabels
    */
    void setRoomSizeLabels( const QStringList & v )
    {
      if (v != mRoomSizeLabels && !isRoomSizeLabelsImmutable()) {
        mRoomSizeLabels = v;
        Q_EMIT roomSizeLabelsChanged();
      }
    }

    Q_PROPERTY(QStringList roomSizeLabels READ roomSizeLabels WRITE setRoomSizeLabels NOTIFY roomSizeLabelsChanged)
    Q_PROPERTY(bool isRoomSizeLabelsImmutable READ isRoomSizeLabelsImmutable CONSTANT)
    Q_PROPERTY(QStringList defaultRoomSizeLabelsValue READ defaultRoomSizeLabelsValue CONSTANT)
    /**
      Get roomSizeLabels
    */
    QStringList roomSizeLabels() const
    {
      return mRoomSizeLabels;
    }

    /**
      Is roomSizeLabels Immutable
    */
    bool isRoomSizeLabelsImmutable() const
    {
      return isImmutable( QStringLiteral( "roomSizeLabels" ) );
    }

    /**
      Get roomSizeLabels default value
    */
    QStringList defaultRoomSizeLabelsValue() const
    {
        return defaultRoomSizeLabelsValue_helper();
    }

    /**
      Set roomSize
    */
    void setRoomSize( int v )
    {
      if (v != mRoomSize && !isRoomSizeImmutable()) {
        mRoomSize = v;
        Q_EMIT roomSizeChanged();
      }
    }

    Q_PROPERTY(int roomSize READ roomSize WRITE setRoomSize NOTIFY roomSizeChanged)
    Q_PROPERTY(bool isRoomSizeImmutable READ isRoomSizeImmutable CONSTANT)
    Q_PROPERTY(int defaultRoomSizeValue READ defaultRoomSizeValue CONSTANT)
    /**
      Get roomSize
    */
    int roomSize() const
    {
      return mRoomSize;
    }

    /**
      Is roomSize Immutable
    */
    bool isRoomSizeImmutable() const
    {
      return isImmutable( QStringLiteral( "roomSize" ) );
    }

    /**
      Get roomSize default value
    */
    int defaultRoomSizeValue() const
    {
        return defaultRoomSizeValue_helper();
    }

    /**
      Set decayTime
    */
    void setDecayTime( double v )
    {
      if (v < 0.4)
      {
        qDebug() << "setDecayTime: value " << v << " is less than the minimum value of 0.4";
        v = 0.4;
      }

      if (v > 15)
      {
        qDebug() << "setDecayTime: value " << v << " is greater than the maximum value of 15";
        v = 15;
      }

      if (v != mDecayTime && !isDecayTimeImmutable()) {
        mDecayTime = v;
        Q_EMIT decayTimeChanged();
      }
    }

    Q_PROPERTY(double decayTime READ decayTime WRITE setDecayTime NOTIFY decayTimeChanged)
    Q_PROPERTY(bool isDecayTimeImmutable READ isDecayTimeImmutable CONSTANT)
    Q_PROPERTY(double defaultDecayTimeValue READ defaultDecayTimeValue CONSTANT)
    /**
      Get decayTime
    */
    double decayTime() const
    {
      return mDecayTime;
    }

    /**
      Is decayTime Immutable
    */
    bool isDecayTimeImmutable() const
    {
      return isImmutable( QStringLiteral( "decayTime" ) );
    }

    /**
      Get decayTime default value
    */
    double defaultDecayTimeValue() const
    {
        return defaultDecayTimeValue_helper();
    }

    /**
      Set hfDamp
    */
    void setHfDamp( double v )
    {
      if (v < 2000)
      {
        qDebug() << "setHfDamp: value " << v << " is less than the minimum value of 2000";
        v = 2000;
      }

      if (v > 20000)
      {
        qDebug() << "setHfDamp: value " << v << " is greater than the maximum value of 20000";
        v = 20000;
      }

      if (v != mHfDamp && !isHfDampImmutable()) {
        mHfDamp = v;
        Q_EMIT hfDampChanged();
      }
    }

    Q_PROPERTY(double hfDamp READ hfDamp WRITE setHfDamp NOTIFY hfDampChanged)
    Q_PROPERTY(bool isHfDampImmutable READ isHfDampImmutable CONSTANT)
    Q_PROPERTY(double defaultHfDampValue READ defaultHfDampValue CONSTANT)
    /**
      Get hfDamp
    */
    double hfDamp() const
    {
      return mHfDamp;
    }

    /**
      Is hfDamp Immutable
    */
    bool isHfDampImmutable() const
    {
      return isImmutable( QStringLiteral( "hfDamp" ) );
    }

    /**
      Get hfDamp default value
    */
    double defaultHfDampValue() const
    {
        return defaultHfDampValue_helper();
    }

    /**
      Set diffusion
    */
    void setDiffusion( double v )
    {
      if (v < 0)
      {
        qDebug() << "setDiffusion: value " << v << " is less than the minimum value of 0";
        v = 0;
      }

      if (v > 1)
      {
        qDebug() << "setDiffusion: value " << v << " is greater than the maximum value of 1";
        v = 1;
      }

      if (v != mDiffusion && !isDiffusionImmutable()) {
        mDiffusion = v;
        Q_EMIT diffusionChanged();
      }
    }

    Q_PROPERTY(double diffusion READ diffusion WRITE setDiffusion NOTIFY diffusionChanged)
    Q_PROPERTY(bool isDiffusionImmutable READ isDiffusionImmutable CONSTANT)
    Q_PROPERTY(double defaultDiffusionValue READ defaultDiffusionValue CONSTANT)
    /**
      Get diffusion
    */
    double diffusion() const
    {
      return mDiffusion;
    }

    /**
      Is diffusion Immutable
    */
    bool isDiffusionImmutable() const
    {
      return isImmutable( QStringLiteral( "diffusion" ) );
    }

    /**
      Get diffusion default value
    */
    double defaultDiffusionValue() const
    {
        return defaultDiffusionValue_helper();
    }

    /**
      Set amount
    */
    void setAmount( double v )
    {
      if (v < -100)
      {
        qDebug() << "setAmount: value " << v << " is less than the minimum value of -100";
        v = -100;
      }

      if (v > 6)
      {
        qDebug() << "setAmount: value " << v << " is greater than the maximum value of 6";
        v = 6;
      }

      if (v != mAmount && !isAmountImmutable()) {
        mAmount = v;
        Q_EMIT amountChanged();
      }
    }

    Q_PROPERTY(double amount READ amount WRITE setAmount NOTIFY amountChanged)
    Q_PROPERTY(bool isAmountImmutable READ isAmountImmutable CONSTANT)
    Q_PROPERTY(double defaultAmountValue READ defaultAmountValue CONSTANT)
    /**
      Get amount
    */
    double amount() const
    {
      return mAmount;
    }

    /**
      Is amount Immutable
    */
    bool isAmountImmutable() const
    {
      return isImmutable( QStringLiteral( "amount" ) );
    }

    /**
      Get amount default value
    */
    double defaultAmountValue() const
    {
        return defaultAmountValue_helper();
    }

    /**
      Set dry
    */
    void setDry( double v )
    {
      if (v < -100)
      {
        qDebug() << "setDry: value " << v << " is less than the minimum value of -100";
        v = -100;
      }

      if (v > 6)
      {
        qDebug() << "setDry: value " << v << " is greater than the maximum value of 6";
        v = 6;
      }

      if (v != mDry && !isDryImmutable()) {
        mDry = v;
        Q_EMIT dryChanged();
      }
    }

    Q_PROPERTY(double dry READ dry WRITE setDry NOTIFY dryChanged)
    Q_PROPERTY(bool isDryImmutable READ isDryImmutable CONSTANT)
    Q_PROPERTY(double defaultDryValue READ defaultDryValue CONSTANT)
    /**
      Get dry
    */
    double dry() const
    {
      return mDry;
    }

    /**
      Is dry Immutable
    */
    bool isDryImmutable() const
    {
      return isImmutable( QStringLiteral( "dry" ) );
    }

    /**
      Get dry default value
    */
    double defaultDryValue() const
    {
        return defaultDryValue_helper();
    }

    /**
      Set predelay
    */
    void setPredelay( double v )
    {
      if (v < 0)
      {
        qDebug() << "setPredelay: value " << v << " is less than the minimum value of 0";
        v = 0;
      }

      if (v > 500)
      {
        qDebug() << "setPredelay: value " << v << " is greater than the maximum value of 500";
        v = 500;
      }

      if (v != mPredelay && !isPredelayImmutable()) {
        mPredelay = v;
        Q_EMIT predelayChanged();
      }
    }

    Q_PROPERTY(double predelay READ predelay WRITE setPredelay NOTIFY predelayChanged)
    Q_PROPERTY(bool isPredelayImmutable READ isPredelayImmutable CONSTANT)
    Q_PROPERTY(double defaultPredelayValue READ defaultPredelayValue CONSTANT)
    /**
      Get predelay
    */
    double predelay() const
    {
      return mPredelay;
    }

    /**
      Is predelay Immutable
    */
    bool isPredelayImmutable() const
    {
      return isImmutable( QStringLiteral( "predelay" ) );
    }

    /**
      Get predelay default value
    */
    double defaultPredelayValue() const
    {
        return defaultPredelayValue_helper();
    }

    /**
      Set bassCut
    */
    void setBassCut( double v )
    {
      if (v < 20)
      {
        qDebug() << "setBassCut: value " << v << " is less than the minimum value of 20";
        v = 20;
      }

      if (v > 20000)
      {
        qDebug() << "setBassCut: value " << v << " is greater than the maximum value of 20000";
        v = 20000;
      }

      if (v != mBassCut && !isBassCutImmutable()) {
        mBassCut = v;
        Q_EMIT bassCutChanged();
      }
    }

    Q_PROPERTY(double bassCut READ bassCut WRITE setBassCut NOTIFY bassCutChanged)
    Q_PROPERTY(bool isBassCutImmutable READ isBassCutImmutable CONSTANT)
    Q_PROPERTY(double defaultBassCutValue READ defaultBassCutValue CONSTANT)
    /**
      Get bassCut
    */
    double bassCut() const
    {
      return mBassCut;
    }

    /**
      Is bassCut Immutable
    */
    bool isBassCutImmutable() const
    {
      return isImmutable( QStringLiteral( "bassCut" ) );
    }

    /**
      Get bassCut default value
    */
    double defaultBassCutValue() const
    {
        return defaultBassCutValue_helper();
    }

    /**
      Set trebleCut
    */
    void setTrebleCut( double v )
    {
      if (v < 20)
      {
        qDebug() << "setTrebleCut: value " << v << " is less than the minimum value of 20";
        v = 20;
      }

      if (v > 20000)
      {
        qDebug() << "setTrebleCut: value " << v << " is greater than the maximum value of 20000";
        v = 20000;
      }

      if (v != mTrebleCut && !isTrebleCutImmutable()) {
        mTrebleCut = v;
        Q_EMIT trebleCutChanged();
      }
    }

    Q_PROPERTY(double trebleCut READ trebleCut WRITE setTrebleCut NOTIFY trebleCutChanged)
    Q_PROPERTY(bool isTrebleCutImmutable READ isTrebleCutImmutable CONSTANT)
    Q_PROPERTY(double defaultTrebleCutValue READ defaultTrebleCutValue CONSTANT)
    /**
      Get trebleCut
    */
    double trebleCut() const
    {
      return mTrebleCut;
    }

    /**
      Is trebleCut Immutable
    */
    bool isTrebleCutImmutable() const
    {
      return isImmutable( QStringLiteral( "trebleCut" ) );
    }

    /**
      Get trebleCut default value
    */
    double defaultTrebleCutValue() const
    {
        return defaultTrebleCutValue_helper();
    }


    enum {
      signalBypassChanged = 1,
      signalInputGainChanged = 2,
      signalOutputGainChanged = 3,
      signalRoomSizeLabelsChanged = 4,
      signalRoomSizeChanged = 5,
      signalDecayTimeChanged = 6,
      signalHfDampChanged = 7,
      signalDiffusionChanged = 8,
      signalAmountChanged = 9,
      signalDryChanged = 10,
      signalPredelayChanged = 11,
      signalBassCutChanged = 12,
      signalTrebleCutChanged = 13
    };

  Q_SIGNALS:
    void bypassChanged();

    void inputGainChanged();

    void outputGainChanged();

    void roomSizeLabelsChanged();

    void roomSizeChanged();

    void decayTimeChanged();

    void hfDampChanged();

    void diffusionChanged();

    void amountChanged();

    void dryChanged();

    void predelayChanged();

    void bassCutChanged();

    void trebleCutChanged();

  private:
    void itemChanged(quint64 signalFlag);

  protected:
    QString mParammasterGroup;
    QString mParaminstanceIndex;

    // Reverb#$(instanceIndex)
    bool mBypass;
    bool defaultBypassValue_helper() const;
    double mInputGain;
    double defaultInputGainValue_helper() const;
    double mOutputGain;
    double defaultOutputGainValue_helper() const;
    QStringList mRoomSizeLabels;
    QStringList defaultRoomSizeLabelsValue_helper() const;
    int mRoomSize;
    int defaultRoomSizeValue_helper() const;
    double mDecayTime;
    double defaultDecayTimeValue_helper() const;
    double mHfDamp;
    double defaultHfDampValue_helper() const;
    double mDiffusion;
    double defaultDiffusionValue_helper() const;
    double mAmount;
    double defaultAmountValue_helper() const;
    double mDry;
    double defaultDryValue_helper() const;
    double mPredelay;
    double defaultPredelayValue_helper() const;
    double mBassCut;
    double defaultBassCutValue_helper() const;
    double mTrebleCut;
    double defaultTrebleCutValue_helper() const;
};

#endif

