// This file is generated by kconfig_compiler_kf6 from easyeffects_db_multiband_compressor.kcfg.
// All changes you do to this file will be lost.

#include "easyeffects_db_multiband_compressor.h"

DbMultibandCompressor::DbMultibandCompressor( const QString & masterGroup, const QString & instanceIndex )
  : KConfigBaseEE( QStringLiteral( "easyeffects/db/multibandcompressorrc" ) )
  , mParammasterGroup(masterGroup)
  , mParaminstanceIndex(instanceIndex)
{
  KConfigCompilerSignallingItem::NotifyFunction notifyFunction = static_cast<KConfigCompilerSignallingItem::NotifyFunction>(&DbMultibandCompressor::itemChanged);

  KConfigGroup cgmasterGroup(this->config(), QStringLiteral( "%1" ).arg( mParammasterGroup ));
  KConfigGroup cgMultibandCompressorinstanceIndex = cgmasterGroup.group(QStringLiteral( "MultibandCompressor#%1" ).arg( mParaminstanceIndex ));
  KConfigCompilerSignallingItem  *itemBypass;
  KConfigBaseEE::ItemBool  *innerItemBypass;
  innerItemBypass = new KConfigBaseEE::ItemBool( currentGroup(), QStringLiteral( "bypass" ), mBypass, false );
  itemBypass = new KConfigCompilerSignallingItem(innerItemBypass, this, notifyFunction, signalBypassChanged);
  itemBypass->setWriteFlags(KConfigBase::Notify);
  itemBypass->setGroup(cgMultibandCompressorinstanceIndex);
  addItem( itemBypass, QStringLiteral( "bypass" ) );
  KConfigCompilerSignallingItem  *itemInputGain;
  KConfigBaseEE::ItemDouble  *innerItemInputGain;
  innerItemInputGain = new KConfigBaseEE::ItemDouble( currentGroup(), QStringLiteral( "inputGain" ), mInputGain, 0 );
  itemInputGain = new KConfigCompilerSignallingItem(innerItemInputGain, this, notifyFunction, signalInputGainChanged);
  innerItemInputGain->setMinValue(-36);
  innerItemInputGain->setMaxValue(36);
  itemInputGain->setWriteFlags(KConfigBase::Notify);
  itemInputGain->setGroup(cgMultibandCompressorinstanceIndex);
  addItem( itemInputGain, QStringLiteral( "inputGain" ) );
  KConfigCompilerSignallingItem  *itemOutputGain;
  KConfigBaseEE::ItemDouble  *innerItemOutputGain;
  innerItemOutputGain = new KConfigBaseEE::ItemDouble( currentGroup(), QStringLiteral( "outputGain" ), mOutputGain, 0 );
  itemOutputGain = new KConfigCompilerSignallingItem(innerItemOutputGain, this, notifyFunction, signalOutputGainChanged);
  innerItemOutputGain->setMinValue(-36);
  innerItemOutputGain->setMaxValue(36);
  itemOutputGain->setWriteFlags(KConfigBase::Notify);
  itemOutputGain->setGroup(cgMultibandCompressorinstanceIndex);
  addItem( itemOutputGain, QStringLiteral( "outputGain" ) );
  KConfigCompilerSignallingItem  *itemDry;
  KConfigBaseEE::ItemDouble  *innerItemDry;
  innerItemDry = new KConfigBaseEE::ItemDouble( currentGroup(), QStringLiteral( "dry" ), mDry, -80.01 );
  itemDry = new KConfigCompilerSignallingItem(innerItemDry, this, notifyFunction, signalDryChanged);
  innerItemDry->setMinValue(-80.01);
  innerItemDry->setMaxValue(20);
  itemDry->setWriteFlags(KConfigBase::Notify);
  itemDry->setGroup(cgMultibandCompressorinstanceIndex);
  addItem( itemDry, QStringLiteral( "dry" ) );
  KConfigCompilerSignallingItem  *itemWet;
  KConfigBaseEE::ItemDouble  *innerItemWet;
  innerItemWet = new KConfigBaseEE::ItemDouble( currentGroup(), QStringLiteral( "wet" ), mWet, 0 );
  itemWet = new KConfigCompilerSignallingItem(innerItemWet, this, notifyFunction, signalWetChanged);
  innerItemWet->setMinValue(-80.01);
  innerItemWet->setMaxValue(20);
  itemWet->setWriteFlags(KConfigBase::Notify);
  itemWet->setGroup(cgMultibandCompressorinstanceIndex);
  addItem( itemWet, QStringLiteral( "wet" ) );
  KConfigCompilerSignallingItem  *itemViewSidechain;
  KConfigBaseEE::ItemBool  *innerItemViewSidechain;
  innerItemViewSidechain = new KConfigBaseEE::ItemBool( currentGroup(), QStringLiteral( "viewSidechain" ), mViewSidechain, false );
  itemViewSidechain = new KConfigCompilerSignallingItem(innerItemViewSidechain, this, notifyFunction, signalViewSidechainChanged);
  itemViewSidechain->setWriteFlags(KConfigBase::Notify);
  itemViewSidechain->setGroup(cgMultibandCompressorinstanceIndex);
  addItem( itemViewSidechain, QStringLiteral( "viewSidechain" ) );
  KConfigCompilerSignallingItem  *itemExternalSidechainEnabled;
  KConfigBaseEE::ItemBool  *innerItemExternalSidechainEnabled;
  innerItemExternalSidechainEnabled = new KConfigBaseEE::ItemBool( currentGroup(), QStringLiteral( "externalSidechainEnabled" ), mExternalSidechainEnabled, false );
  itemExternalSidechainEnabled = new KConfigCompilerSignallingItem(innerItemExternalSidechainEnabled, this, notifyFunction, signalExternalSidechainEnabledChanged);
  itemExternalSidechainEnabled->setWriteFlags(KConfigBase::Notify);
  itemExternalSidechainEnabled->setGroup(cgMultibandCompressorinstanceIndex);
  addItem( itemExternalSidechainEnabled, QStringLiteral( "externalSidechainEnabled" ) );
  KConfigCompilerSignallingItem  *itemStereoSplit;
  KConfigBaseEE::ItemBool  *innerItemStereoSplit;
  innerItemStereoSplit = new KConfigBaseEE::ItemBool( currentGroup(), QStringLiteral( "stereoSplit" ), mStereoSplit, false );
  itemStereoSplit = new KConfigCompilerSignallingItem(innerItemStereoSplit, this, notifyFunction, signalStereoSplitChanged);
  itemStereoSplit->setWriteFlags(KConfigBase::Notify);
  itemStereoSplit->setGroup(cgMultibandCompressorinstanceIndex);
  addItem( itemStereoSplit, QStringLiteral( "stereoSplit" ) );
  QStringList defaultcompressorModeLabels;
  defaultcompressorModeLabels.append( QString::fromUtf8( "Classic" ) );
  defaultcompressorModeLabels.append( QString::fromUtf8( "Modern" ) );
  defaultcompressorModeLabels.append( QString::fromUtf8( "Linear Phase" ) );

  KConfigCompilerSignallingItem  *itemCompressorModeLabels;
  KConfigBaseEE::ItemStringList  *innerItemCompressorModeLabels;
  innerItemCompressorModeLabels = new KConfigBaseEE::ItemStringList( currentGroup(), QStringLiteral( "compressorModeLabels" ), mCompressorModeLabels, defaultcompressorModeLabels );
  itemCompressorModeLabels = new KConfigCompilerSignallingItem(innerItemCompressorModeLabels, this, notifyFunction, signalCompressorModeLabelsChanged);
  itemCompressorModeLabels->setWriteFlags(KConfigBase::Notify);
  itemCompressorModeLabels->setGroup(cgMultibandCompressorinstanceIndex);
  addItem( itemCompressorModeLabels, QStringLiteral( "compressorModeLabels" ) );
  KConfigCompilerSignallingItem  *itemCompressorMode;
  KConfigBaseEE::ItemInt  *innerItemCompressorMode;
  innerItemCompressorMode = new KConfigBaseEE::ItemInt( currentGroup(), QStringLiteral( "compressorMode" ), mCompressorMode, 1 );
  itemCompressorMode = new KConfigCompilerSignallingItem(innerItemCompressorMode, this, notifyFunction, signalCompressorModeChanged);
  itemCompressorMode->setWriteFlags(KConfigBase::Notify);
  itemCompressorMode->setGroup(cgMultibandCompressorinstanceIndex);
  addItem( itemCompressorMode, QStringLiteral( "compressorMode" ) );
  QStringList defaultenvelopeBoostLabels;
  defaultenvelopeBoostLabels.append( QString::fromUtf8( "None" ) );
  defaultenvelopeBoostLabels.append( QString::fromUtf8( "Pink BT" ) );
  defaultenvelopeBoostLabels.append( QString::fromUtf8( "Pink MT" ) );
  defaultenvelopeBoostLabels.append( QString::fromUtf8( "Brown BT" ) );
  defaultenvelopeBoostLabels.append( QString::fromUtf8( "Brown MT" ) );

  KConfigCompilerSignallingItem  *itemEnvelopeBoostLabels;
  KConfigBaseEE::ItemStringList  *innerItemEnvelopeBoostLabels;
  innerItemEnvelopeBoostLabels = new KConfigBaseEE::ItemStringList( currentGroup(), QStringLiteral( "envelopeBoostLabels" ), mEnvelopeBoostLabels, defaultenvelopeBoostLabels );
  itemEnvelopeBoostLabels = new KConfigCompilerSignallingItem(innerItemEnvelopeBoostLabels, this, notifyFunction, signalEnvelopeBoostLabelsChanged);
  itemEnvelopeBoostLabels->setWriteFlags(KConfigBase::Notify);
  itemEnvelopeBoostLabels->setGroup(cgMultibandCompressorinstanceIndex);
  addItem( itemEnvelopeBoostLabels, QStringLiteral( "envelopeBoostLabels" ) );
  KConfigCompilerSignallingItem  *itemEnvelopeBoost;
  KConfigBaseEE::ItemInt  *innerItemEnvelopeBoost;
  innerItemEnvelopeBoost = new KConfigBaseEE::ItemInt( currentGroup(), QStringLiteral( "envelopeBoost" ), mEnvelopeBoost, 0 );
  itemEnvelopeBoost = new KConfigCompilerSignallingItem(innerItemEnvelopeBoost, this, notifyFunction, signalEnvelopeBoostChanged);
  itemEnvelopeBoost->setWriteFlags(KConfigBase::Notify);
  itemEnvelopeBoost->setGroup(cgMultibandCompressorinstanceIndex);
  addItem( itemEnvelopeBoost, QStringLiteral( "envelopeBoost" ) );
  KConfigCompilerSignallingItem  *itemInputToSidechain;
  KConfigBaseEE::ItemDouble  *innerItemInputToSidechain;
  innerItemInputToSidechain = new KConfigBaseEE::ItemDouble( currentGroup(), QStringLiteral( "inputToSidechain" ), mInputToSidechain, -80.01 );
  itemInputToSidechain = new KConfigCompilerSignallingItem(innerItemInputToSidechain, this, notifyFunction, signalInputToSidechainChanged);
  innerItemInputToSidechain->setMinValue(-80.01);
  innerItemInputToSidechain->setMaxValue(40);
  itemInputToSidechain->setWriteFlags(KConfigBase::Notify);
  itemInputToSidechain->setGroup(cgMultibandCompressorinstanceIndex);
  addItem( itemInputToSidechain, QStringLiteral( "inputToSidechain" ) );
  KConfigCompilerSignallingItem  *itemInputToLink;
  KConfigBaseEE::ItemDouble  *innerItemInputToLink;
  innerItemInputToLink = new KConfigBaseEE::ItemDouble( currentGroup(), QStringLiteral( "inputToLink" ), mInputToLink, -80.01 );
  itemInputToLink = new KConfigCompilerSignallingItem(innerItemInputToLink, this, notifyFunction, signalInputToLinkChanged);
  innerItemInputToLink->setMinValue(-80.01);
  innerItemInputToLink->setMaxValue(40);
  itemInputToLink->setWriteFlags(KConfigBase::Notify);
  itemInputToLink->setGroup(cgMultibandCompressorinstanceIndex);
  addItem( itemInputToLink, QStringLiteral( "inputToLink" ) );
  KConfigCompilerSignallingItem  *itemSidechainToInput;
  KConfigBaseEE::ItemDouble  *innerItemSidechainToInput;
  innerItemSidechainToInput = new KConfigBaseEE::ItemDouble( currentGroup(), QStringLiteral( "sidechainToInput" ), mSidechainToInput, -80.01 );
  itemSidechainToInput = new KConfigCompilerSignallingItem(innerItemSidechainToInput, this, notifyFunction, signalSidechainToInputChanged);
  innerItemSidechainToInput->setMinValue(-80.01);
  innerItemSidechainToInput->setMaxValue(40);
  itemSidechainToInput->setWriteFlags(KConfigBase::Notify);
  itemSidechainToInput->setGroup(cgMultibandCompressorinstanceIndex);
  addItem( itemSidechainToInput, QStringLiteral( "sidechainToInput" ) );
  KConfigCompilerSignallingItem  *itemSidechainToLink;
  KConfigBaseEE::ItemDouble  *innerItemSidechainToLink;
  innerItemSidechainToLink = new KConfigBaseEE::ItemDouble( currentGroup(), QStringLiteral( "sidechainToLink" ), mSidechainToLink, -80.01 );
  itemSidechainToLink = new KConfigCompilerSignallingItem(innerItemSidechainToLink, this, notifyFunction, signalSidechainToLinkChanged);
  innerItemSidechainToLink->setMinValue(-80.01);
  innerItemSidechainToLink->setMaxValue(40);
  itemSidechainToLink->setWriteFlags(KConfigBase::Notify);
  itemSidechainToLink->setGroup(cgMultibandCompressorinstanceIndex);
  addItem( itemSidechainToLink, QStringLiteral( "sidechainToLink" ) );
  KConfigCompilerSignallingItem  *itemLinkToSidechain;
  KConfigBaseEE::ItemDouble  *innerItemLinkToSidechain;
  innerItemLinkToSidechain = new KConfigBaseEE::ItemDouble( currentGroup(), QStringLiteral( "linkToSidechain" ), mLinkToSidechain, -80.01 );
  itemLinkToSidechain = new KConfigCompilerSignallingItem(innerItemLinkToSidechain, this, notifyFunction, signalLinkToSidechainChanged);
  innerItemLinkToSidechain->setMinValue(-80.01);
  innerItemLinkToSidechain->setMaxValue(40);
  itemLinkToSidechain->setWriteFlags(KConfigBase::Notify);
  itemLinkToSidechain->setGroup(cgMultibandCompressorinstanceIndex);
  addItem( itemLinkToSidechain, QStringLiteral( "linkToSidechain" ) );
  KConfigCompilerSignallingItem  *itemLinkToInput;
  KConfigBaseEE::ItemDouble  *innerItemLinkToInput;
  innerItemLinkToInput = new KConfigBaseEE::ItemDouble( currentGroup(), QStringLiteral( "linkToInput" ), mLinkToInput, -80.01 );
  itemLinkToInput = new KConfigCompilerSignallingItem(innerItemLinkToInput, this, notifyFunction, signalLinkToInputChanged);
  innerItemLinkToInput->setMinValue(-80.01);
  innerItemLinkToInput->setMaxValue(40);
  itemLinkToInput->setWriteFlags(KConfigBase::Notify);
  itemLinkToInput->setGroup(cgMultibandCompressorinstanceIndex);
  addItem( itemLinkToInput, QStringLiteral( "linkToInput" ) );
  KConfigCompilerSignallingItem  *itemBand1Enable;
  KConfigBaseEE::ItemBool  *innerItemBand1Enable;
  innerItemBand1Enable = new KConfigBaseEE::ItemBool( currentGroup(), QStringLiteral( "band1Enable" ), mBand1Enable, true );
  itemBand1Enable = new KConfigCompilerSignallingItem(innerItemBand1Enable, this, notifyFunction, signalBand1EnableChanged);
  itemBand1Enable->setWriteFlags(KConfigBase::Notify);
  itemBand1Enable->setGroup(cgMultibandCompressorinstanceIndex);
  addItem( itemBand1Enable, QStringLiteral( "band1Enable" ) );
  KConfigCompilerSignallingItem  *itemBand2Enable;
  KConfigBaseEE::ItemBool  *innerItemBand2Enable;
  innerItemBand2Enable = new KConfigBaseEE::ItemBool( currentGroup(), QStringLiteral( "band2Enable" ), mBand2Enable, true );
  itemBand2Enable = new KConfigCompilerSignallingItem(innerItemBand2Enable, this, notifyFunction, signalBand2EnableChanged);
  itemBand2Enable->setWriteFlags(KConfigBase::Notify);
  itemBand2Enable->setGroup(cgMultibandCompressorinstanceIndex);
  addItem( itemBand2Enable, QStringLiteral( "band2Enable" ) );
  KConfigCompilerSignallingItem  *itemBand3Enable;
  KConfigBaseEE::ItemBool  *innerItemBand3Enable;
  innerItemBand3Enable = new KConfigBaseEE::ItemBool( currentGroup(), QStringLiteral( "band3Enable" ), mBand3Enable, true );
  itemBand3Enable = new KConfigCompilerSignallingItem(innerItemBand3Enable, this, notifyFunction, signalBand3EnableChanged);
  itemBand3Enable->setWriteFlags(KConfigBase::Notify);
  itemBand3Enable->setGroup(cgMultibandCompressorinstanceIndex);
  addItem( itemBand3Enable, QStringLiteral( "band3Enable" ) );
  KConfigCompilerSignallingItem  *itemBand4Enable;
  KConfigBaseEE::ItemBool  *innerItemBand4Enable;
  innerItemBand4Enable = new KConfigBaseEE::ItemBool( currentGroup(), QStringLiteral( "band4Enable" ), mBand4Enable, false );
  itemBand4Enable = new KConfigCompilerSignallingItem(innerItemBand4Enable, this, notifyFunction, signalBand4EnableChanged);
  itemBand4Enable->setWriteFlags(KConfigBase::Notify);
  itemBand4Enable->setGroup(cgMultibandCompressorinstanceIndex);
  addItem( itemBand4Enable, QStringLiteral( "band4Enable" ) );
  KConfigCompilerSignallingItem  *itemBand5Enable;
  KConfigBaseEE::ItemBool  *innerItemBand5Enable;
  innerItemBand5Enable = new KConfigBaseEE::ItemBool( currentGroup(), QStringLiteral( "band5Enable" ), mBand5Enable, false );
  itemBand5Enable = new KConfigCompilerSignallingItem(innerItemBand5Enable, this, notifyFunction, signalBand5EnableChanged);
  itemBand5Enable->setWriteFlags(KConfigBase::Notify);
  itemBand5Enable->setGroup(cgMultibandCompressorinstanceIndex);
  addItem( itemBand5Enable, QStringLiteral( "band5Enable" ) );
  KConfigCompilerSignallingItem  *itemBand6Enable;
  KConfigBaseEE::ItemBool  *innerItemBand6Enable;
  innerItemBand6Enable = new KConfigBaseEE::ItemBool( currentGroup(), QStringLiteral( "band6Enable" ), mBand6Enable, false );
  itemBand6Enable = new KConfigCompilerSignallingItem(innerItemBand6Enable, this, notifyFunction, signalBand6EnableChanged);
  itemBand6Enable->setWriteFlags(KConfigBase::Notify);
  itemBand6Enable->setGroup(cgMultibandCompressorinstanceIndex);
  addItem( itemBand6Enable, QStringLiteral( "band6Enable" ) );
  KConfigCompilerSignallingItem  *itemBand7Enable;
  KConfigBaseEE::ItemBool  *innerItemBand7Enable;
  innerItemBand7Enable = new KConfigBaseEE::ItemBool( currentGroup(), QStringLiteral( "band7Enable" ), mBand7Enable, false );
  itemBand7Enable = new KConfigCompilerSignallingItem(innerItemBand7Enable, this, notifyFunction, signalBand7EnableChanged);
  itemBand7Enable->setWriteFlags(KConfigBase::Notify);
  itemBand7Enable->setGroup(cgMultibandCompressorinstanceIndex);
  addItem( itemBand7Enable, QStringLiteral( "band7Enable" ) );
  KConfigCompilerSignallingItem  *itemBand1SplitFrequency;
  KConfigBaseEE::ItemDouble  *innerItemBand1SplitFrequency;
  innerItemBand1SplitFrequency = new KConfigBaseEE::ItemDouble( currentGroup(), QStringLiteral( "band1SplitFrequency" ), mBand1SplitFrequency, 500 );
  itemBand1SplitFrequency = new KConfigCompilerSignallingItem(innerItemBand1SplitFrequency, this, notifyFunction, signalBand1SplitFrequencyChanged);
  innerItemBand1SplitFrequency->setMinValue(10);
  innerItemBand1SplitFrequency->setMaxValue(20000);
  itemBand1SplitFrequency->setWriteFlags(KConfigBase::Notify);
  itemBand1SplitFrequency->setGroup(cgMultibandCompressorinstanceIndex);
  addItem( itemBand1SplitFrequency, QStringLiteral( "band1SplitFrequency" ) );
  KConfigCompilerSignallingItem  *itemBand2SplitFrequency;
  KConfigBaseEE::ItemDouble  *innerItemBand2SplitFrequency;
  innerItemBand2SplitFrequency = new KConfigBaseEE::ItemDouble( currentGroup(), QStringLiteral( "band2SplitFrequency" ), mBand2SplitFrequency, 1000 );
  itemBand2SplitFrequency = new KConfigCompilerSignallingItem(innerItemBand2SplitFrequency, this, notifyFunction, signalBand2SplitFrequencyChanged);
  innerItemBand2SplitFrequency->setMinValue(10);
  innerItemBand2SplitFrequency->setMaxValue(20000);
  itemBand2SplitFrequency->setWriteFlags(KConfigBase::Notify);
  itemBand2SplitFrequency->setGroup(cgMultibandCompressorinstanceIndex);
  addItem( itemBand2SplitFrequency, QStringLiteral( "band2SplitFrequency" ) );
  KConfigCompilerSignallingItem  *itemBand3SplitFrequency;
  KConfigBaseEE::ItemDouble  *innerItemBand3SplitFrequency;
  innerItemBand3SplitFrequency = new KConfigBaseEE::ItemDouble( currentGroup(), QStringLiteral( "band3SplitFrequency" ), mBand3SplitFrequency, 2000 );
  itemBand3SplitFrequency = new KConfigCompilerSignallingItem(innerItemBand3SplitFrequency, this, notifyFunction, signalBand3SplitFrequencyChanged);
  innerItemBand3SplitFrequency->setMinValue(10);
  innerItemBand3SplitFrequency->setMaxValue(20000);
  itemBand3SplitFrequency->setWriteFlags(KConfigBase::Notify);
  itemBand3SplitFrequency->setGroup(cgMultibandCompressorinstanceIndex);
  addItem( itemBand3SplitFrequency, QStringLiteral( "band3SplitFrequency" ) );
  KConfigCompilerSignallingItem  *itemBand4SplitFrequency;
  KConfigBaseEE::ItemDouble  *innerItemBand4SplitFrequency;
  innerItemBand4SplitFrequency = new KConfigBaseEE::ItemDouble( currentGroup(), QStringLiteral( "band4SplitFrequency" ), mBand4SplitFrequency, 4000 );
  itemBand4SplitFrequency = new KConfigCompilerSignallingItem(innerItemBand4SplitFrequency, this, notifyFunction, signalBand4SplitFrequencyChanged);
  innerItemBand4SplitFrequency->setMinValue(10);
  innerItemBand4SplitFrequency->setMaxValue(20000);
  itemBand4SplitFrequency->setWriteFlags(KConfigBase::Notify);
  itemBand4SplitFrequency->setGroup(cgMultibandCompressorinstanceIndex);
  addItem( itemBand4SplitFrequency, QStringLiteral( "band4SplitFrequency" ) );
  KConfigCompilerSignallingItem  *itemBand5SplitFrequency;
  KConfigBaseEE::ItemDouble  *innerItemBand5SplitFrequency;
  innerItemBand5SplitFrequency = new KConfigBaseEE::ItemDouble( currentGroup(), QStringLiteral( "band5SplitFrequency" ), mBand5SplitFrequency, 8000 );
  itemBand5SplitFrequency = new KConfigCompilerSignallingItem(innerItemBand5SplitFrequency, this, notifyFunction, signalBand5SplitFrequencyChanged);
  innerItemBand5SplitFrequency->setMinValue(10);
  innerItemBand5SplitFrequency->setMaxValue(20000);
  itemBand5SplitFrequency->setWriteFlags(KConfigBase::Notify);
  itemBand5SplitFrequency->setGroup(cgMultibandCompressorinstanceIndex);
  addItem( itemBand5SplitFrequency, QStringLiteral( "band5SplitFrequency" ) );
  KConfigCompilerSignallingItem  *itemBand6SplitFrequency;
  KConfigBaseEE::ItemDouble  *innerItemBand6SplitFrequency;
  innerItemBand6SplitFrequency = new KConfigBaseEE::ItemDouble( currentGroup(), QStringLiteral( "band6SplitFrequency" ), mBand6SplitFrequency, 12000 );
  itemBand6SplitFrequency = new KConfigCompilerSignallingItem(innerItemBand6SplitFrequency, this, notifyFunction, signalBand6SplitFrequencyChanged);
  innerItemBand6SplitFrequency->setMinValue(10);
  innerItemBand6SplitFrequency->setMaxValue(20000);
  itemBand6SplitFrequency->setWriteFlags(KConfigBase::Notify);
  itemBand6SplitFrequency->setGroup(cgMultibandCompressorinstanceIndex);
  addItem( itemBand6SplitFrequency, QStringLiteral( "band6SplitFrequency" ) );
  KConfigCompilerSignallingItem  *itemBand7SplitFrequency;
  KConfigBaseEE::ItemDouble  *innerItemBand7SplitFrequency;
  innerItemBand7SplitFrequency = new KConfigBaseEE::ItemDouble( currentGroup(), QStringLiteral( "band7SplitFrequency" ), mBand7SplitFrequency, 16000 );
  itemBand7SplitFrequency = new KConfigCompilerSignallingItem(innerItemBand7SplitFrequency, this, notifyFunction, signalBand7SplitFrequencyChanged);
  innerItemBand7SplitFrequency->setMinValue(10);
  innerItemBand7SplitFrequency->setMaxValue(20000);
  itemBand7SplitFrequency->setWriteFlags(KConfigBase::Notify);
  itemBand7SplitFrequency->setGroup(cgMultibandCompressorinstanceIndex);
  addItem( itemBand7SplitFrequency, QStringLiteral( "band7SplitFrequency" ) );
  KConfigCompilerSignallingItem  *itemSidechainInputDevice;
  KConfigBaseEE::ItemString  *innerItemSidechainInputDevice;
  innerItemSidechainInputDevice = new KConfigBaseEE::ItemString( currentGroup(), QStringLiteral( "sidechainInputDevice" ), mSidechainInputDevice, QStringLiteral( "\"\"" ) );
  itemSidechainInputDevice = new KConfigCompilerSignallingItem(innerItemSidechainInputDevice, this, notifyFunction, signalSidechainInputDeviceChanged);
  itemSidechainInputDevice->setWriteFlags(KConfigBase::Notify);
  itemSidechainInputDevice->setGroup(cgMultibandCompressorinstanceIndex);
  addItem( itemSidechainInputDevice, QStringLiteral( "sidechainInputDevice" ) );
  QStringList defaultsidechainTypeLabels;
  defaultsidechainTypeLabels.append( QString::fromUtf8( "Internal" ) );
  defaultsidechainTypeLabels.append( QString::fromUtf8( "External" ) );
  defaultsidechainTypeLabels.append( QString::fromUtf8( "Link" ) );

  KConfigCompilerSignallingItem  *itemSidechainTypeLabels;
  KConfigBaseEE::ItemStringList  *innerItemSidechainTypeLabels;
  innerItemSidechainTypeLabels = new KConfigBaseEE::ItemStringList( currentGroup(), QStringLiteral( "sidechainTypeLabels" ), mSidechainTypeLabels, defaultsidechainTypeLabels );
  itemSidechainTypeLabels = new KConfigCompilerSignallingItem(innerItemSidechainTypeLabels, this, notifyFunction, signalSidechainTypeLabelsChanged);
  itemSidechainTypeLabels->setWriteFlags(KConfigBase::Notify);
  itemSidechainTypeLabels->setGroup(cgMultibandCompressorinstanceIndex);
  addItem( itemSidechainTypeLabels, QStringLiteral( "sidechainTypeLabels" ) );
  KConfigCompilerSignallingItem  *itemBand0SidechainType;
  KConfigBaseEE::ItemInt  *innerItemBand0SidechainType;
  innerItemBand0SidechainType = new KConfigBaseEE::ItemInt( currentGroup(), QStringLiteral( "band0SidechainType" ), mBand0SidechainType, 0 );
  itemBand0SidechainType = new KConfigCompilerSignallingItem(innerItemBand0SidechainType, this, notifyFunction, signalBand0SidechainTypeChanged);
  itemBand0SidechainType->setWriteFlags(KConfigBase::Notify);
  itemBand0SidechainType->setGroup(cgMultibandCompressorinstanceIndex);
  addItem( itemBand0SidechainType, QStringLiteral( "band0SidechainType" ) );
  KConfigCompilerSignallingItem  *itemBand1SidechainType;
  KConfigBaseEE::ItemInt  *innerItemBand1SidechainType;
  innerItemBand1SidechainType = new KConfigBaseEE::ItemInt( currentGroup(), QStringLiteral( "band1SidechainType" ), mBand1SidechainType, 0 );
  itemBand1SidechainType = new KConfigCompilerSignallingItem(innerItemBand1SidechainType, this, notifyFunction, signalBand1SidechainTypeChanged);
  itemBand1SidechainType->setWriteFlags(KConfigBase::Notify);
  itemBand1SidechainType->setGroup(cgMultibandCompressorinstanceIndex);
  addItem( itemBand1SidechainType, QStringLiteral( "band1SidechainType" ) );
  KConfigCompilerSignallingItem  *itemBand2SidechainType;
  KConfigBaseEE::ItemInt  *innerItemBand2SidechainType;
  innerItemBand2SidechainType = new KConfigBaseEE::ItemInt( currentGroup(), QStringLiteral( "band2SidechainType" ), mBand2SidechainType, 0 );
  itemBand2SidechainType = new KConfigCompilerSignallingItem(innerItemBand2SidechainType, this, notifyFunction, signalBand2SidechainTypeChanged);
  itemBand2SidechainType->setWriteFlags(KConfigBase::Notify);
  itemBand2SidechainType->setGroup(cgMultibandCompressorinstanceIndex);
  addItem( itemBand2SidechainType, QStringLiteral( "band2SidechainType" ) );
  KConfigCompilerSignallingItem  *itemBand3SidechainType;
  KConfigBaseEE::ItemInt  *innerItemBand3SidechainType;
  innerItemBand3SidechainType = new KConfigBaseEE::ItemInt( currentGroup(), QStringLiteral( "band3SidechainType" ), mBand3SidechainType, 0 );
  itemBand3SidechainType = new KConfigCompilerSignallingItem(innerItemBand3SidechainType, this, notifyFunction, signalBand3SidechainTypeChanged);
  itemBand3SidechainType->setWriteFlags(KConfigBase::Notify);
  itemBand3SidechainType->setGroup(cgMultibandCompressorinstanceIndex);
  addItem( itemBand3SidechainType, QStringLiteral( "band3SidechainType" ) );
  KConfigCompilerSignallingItem  *itemBand4SidechainType;
  KConfigBaseEE::ItemInt  *innerItemBand4SidechainType;
  innerItemBand4SidechainType = new KConfigBaseEE::ItemInt( currentGroup(), QStringLiteral( "band4SidechainType" ), mBand4SidechainType, 0 );
  itemBand4SidechainType = new KConfigCompilerSignallingItem(innerItemBand4SidechainType, this, notifyFunction, signalBand4SidechainTypeChanged);
  itemBand4SidechainType->setWriteFlags(KConfigBase::Notify);
  itemBand4SidechainType->setGroup(cgMultibandCompressorinstanceIndex);
  addItem( itemBand4SidechainType, QStringLiteral( "band4SidechainType" ) );
  KConfigCompilerSignallingItem  *itemBand5SidechainType;
  KConfigBaseEE::ItemInt  *innerItemBand5SidechainType;
  innerItemBand5SidechainType = new KConfigBaseEE::ItemInt( currentGroup(), QStringLiteral( "band5SidechainType" ), mBand5SidechainType, 0 );
  itemBand5SidechainType = new KConfigCompilerSignallingItem(innerItemBand5SidechainType, this, notifyFunction, signalBand5SidechainTypeChanged);
  itemBand5SidechainType->setWriteFlags(KConfigBase::Notify);
  itemBand5SidechainType->setGroup(cgMultibandCompressorinstanceIndex);
  addItem( itemBand5SidechainType, QStringLiteral( "band5SidechainType" ) );
  KConfigCompilerSignallingItem  *itemBand6SidechainType;
  KConfigBaseEE::ItemInt  *innerItemBand6SidechainType;
  innerItemBand6SidechainType = new KConfigBaseEE::ItemInt( currentGroup(), QStringLiteral( "band6SidechainType" ), mBand6SidechainType, 0 );
  itemBand6SidechainType = new KConfigCompilerSignallingItem(innerItemBand6SidechainType, this, notifyFunction, signalBand6SidechainTypeChanged);
  itemBand6SidechainType->setWriteFlags(KConfigBase::Notify);
  itemBand6SidechainType->setGroup(cgMultibandCompressorinstanceIndex);
  addItem( itemBand6SidechainType, QStringLiteral( "band6SidechainType" ) );
  KConfigCompilerSignallingItem  *itemBand7SidechainType;
  KConfigBaseEE::ItemInt  *innerItemBand7SidechainType;
  innerItemBand7SidechainType = new KConfigBaseEE::ItemInt( currentGroup(), QStringLiteral( "band7SidechainType" ), mBand7SidechainType, 0 );
  itemBand7SidechainType = new KConfigCompilerSignallingItem(innerItemBand7SidechainType, this, notifyFunction, signalBand7SidechainTypeChanged);
  itemBand7SidechainType->setWriteFlags(KConfigBase::Notify);
  itemBand7SidechainType->setGroup(cgMultibandCompressorinstanceIndex);
  addItem( itemBand7SidechainType, QStringLiteral( "band7SidechainType" ) );
  QStringList defaultsidechainModeLabels;
  defaultsidechainModeLabels.append( QString::fromUtf8( "Peak" ) );
  defaultsidechainModeLabels.append( QString::fromUtf8( "RMS" ) );
  defaultsidechainModeLabels.append( QString::fromUtf8( "LPF" ) );
  defaultsidechainModeLabels.append( QString::fromUtf8( "SMA" ) );

  KConfigCompilerSignallingItem  *itemSidechainModeLabels;
  KConfigBaseEE::ItemStringList  *innerItemSidechainModeLabels;
  innerItemSidechainModeLabels = new KConfigBaseEE::ItemStringList( currentGroup(), QStringLiteral( "sidechainModeLabels" ), mSidechainModeLabels, defaultsidechainModeLabels );
  itemSidechainModeLabels = new KConfigCompilerSignallingItem(innerItemSidechainModeLabels, this, notifyFunction, signalSidechainModeLabelsChanged);
  itemSidechainModeLabels->setWriteFlags(KConfigBase::Notify);
  itemSidechainModeLabels->setGroup(cgMultibandCompressorinstanceIndex);
  addItem( itemSidechainModeLabels, QStringLiteral( "sidechainModeLabels" ) );
  KConfigCompilerSignallingItem  *itemBand0SidechainMode;
  KConfigBaseEE::ItemInt  *innerItemBand0SidechainMode;
  innerItemBand0SidechainMode = new KConfigBaseEE::ItemInt( currentGroup(), QStringLiteral( "band0SidechainMode" ), mBand0SidechainMode, 1 );
  itemBand0SidechainMode = new KConfigCompilerSignallingItem(innerItemBand0SidechainMode, this, notifyFunction, signalBand0SidechainModeChanged);
  itemBand0SidechainMode->setWriteFlags(KConfigBase::Notify);
  itemBand0SidechainMode->setGroup(cgMultibandCompressorinstanceIndex);
  addItem( itemBand0SidechainMode, QStringLiteral( "band0SidechainMode" ) );
  KConfigCompilerSignallingItem  *itemBand1SidechainMode;
  KConfigBaseEE::ItemInt  *innerItemBand1SidechainMode;
  innerItemBand1SidechainMode = new KConfigBaseEE::ItemInt( currentGroup(), QStringLiteral( "band1SidechainMode" ), mBand1SidechainMode, 1 );
  itemBand1SidechainMode = new KConfigCompilerSignallingItem(innerItemBand1SidechainMode, this, notifyFunction, signalBand1SidechainModeChanged);
  itemBand1SidechainMode->setWriteFlags(KConfigBase::Notify);
  itemBand1SidechainMode->setGroup(cgMultibandCompressorinstanceIndex);
  addItem( itemBand1SidechainMode, QStringLiteral( "band1SidechainMode" ) );
  KConfigCompilerSignallingItem  *itemBand2SidechainMode;
  KConfigBaseEE::ItemInt  *innerItemBand2SidechainMode;
  innerItemBand2SidechainMode = new KConfigBaseEE::ItemInt( currentGroup(), QStringLiteral( "band2SidechainMode" ), mBand2SidechainMode, 1 );
  itemBand2SidechainMode = new KConfigCompilerSignallingItem(innerItemBand2SidechainMode, this, notifyFunction, signalBand2SidechainModeChanged);
  itemBand2SidechainMode->setWriteFlags(KConfigBase::Notify);
  itemBand2SidechainMode->setGroup(cgMultibandCompressorinstanceIndex);
  addItem( itemBand2SidechainMode, QStringLiteral( "band2SidechainMode" ) );
  KConfigCompilerSignallingItem  *itemBand3SidechainMode;
  KConfigBaseEE::ItemInt  *innerItemBand3SidechainMode;
  innerItemBand3SidechainMode = new KConfigBaseEE::ItemInt( currentGroup(), QStringLiteral( "band3SidechainMode" ), mBand3SidechainMode, 1 );
  itemBand3SidechainMode = new KConfigCompilerSignallingItem(innerItemBand3SidechainMode, this, notifyFunction, signalBand3SidechainModeChanged);
  itemBand3SidechainMode->setWriteFlags(KConfigBase::Notify);
  itemBand3SidechainMode->setGroup(cgMultibandCompressorinstanceIndex);
  addItem( itemBand3SidechainMode, QStringLiteral( "band3SidechainMode" ) );
  KConfigCompilerSignallingItem  *itemBand4SidechainMode;
  KConfigBaseEE::ItemInt  *innerItemBand4SidechainMode;
  innerItemBand4SidechainMode = new KConfigBaseEE::ItemInt( currentGroup(), QStringLiteral( "band4SidechainMode" ), mBand4SidechainMode, 1 );
  itemBand4SidechainMode = new KConfigCompilerSignallingItem(innerItemBand4SidechainMode, this, notifyFunction, signalBand4SidechainModeChanged);
  itemBand4SidechainMode->setWriteFlags(KConfigBase::Notify);
  itemBand4SidechainMode->setGroup(cgMultibandCompressorinstanceIndex);
  addItem( itemBand4SidechainMode, QStringLiteral( "band4SidechainMode" ) );
  KConfigCompilerSignallingItem  *itemBand5SidechainMode;
  KConfigBaseEE::ItemInt  *innerItemBand5SidechainMode;
  innerItemBand5SidechainMode = new KConfigBaseEE::ItemInt( currentGroup(), QStringLiteral( "band5SidechainMode" ), mBand5SidechainMode, 1 );
  itemBand5SidechainMode = new KConfigCompilerSignallingItem(innerItemBand5SidechainMode, this, notifyFunction, signalBand5SidechainModeChanged);
  itemBand5SidechainMode->setWriteFlags(KConfigBase::Notify);
  itemBand5SidechainMode->setGroup(cgMultibandCompressorinstanceIndex);
  addItem( itemBand5SidechainMode, QStringLiteral( "band5SidechainMode" ) );
  KConfigCompilerSignallingItem  *itemBand6SidechainMode;
  KConfigBaseEE::ItemInt  *innerItemBand6SidechainMode;
  innerItemBand6SidechainMode = new KConfigBaseEE::ItemInt( currentGroup(), QStringLiteral( "band6SidechainMode" ), mBand6SidechainMode, 1 );
  itemBand6SidechainMode = new KConfigCompilerSignallingItem(innerItemBand6SidechainMode, this, notifyFunction, signalBand6SidechainModeChanged);
  itemBand6SidechainMode->setWriteFlags(KConfigBase::Notify);
  itemBand6SidechainMode->setGroup(cgMultibandCompressorinstanceIndex);
  addItem( itemBand6SidechainMode, QStringLiteral( "band6SidechainMode" ) );
  KConfigCompilerSignallingItem  *itemBand7SidechainMode;
  KConfigBaseEE::ItemInt  *innerItemBand7SidechainMode;
  innerItemBand7SidechainMode = new KConfigBaseEE::ItemInt( currentGroup(), QStringLiteral( "band7SidechainMode" ), mBand7SidechainMode, 1 );
  itemBand7SidechainMode = new KConfigCompilerSignallingItem(innerItemBand7SidechainMode, this, notifyFunction, signalBand7SidechainModeChanged);
  itemBand7SidechainMode->setWriteFlags(KConfigBase::Notify);
  itemBand7SidechainMode->setGroup(cgMultibandCompressorinstanceIndex);
  addItem( itemBand7SidechainMode, QStringLiteral( "band7SidechainMode" ) );
  QStringList defaultsidechainSourceLabels;
  defaultsidechainSourceLabels.append( QString::fromUtf8( "Middle" ) );
  defaultsidechainSourceLabels.append( QString::fromUtf8( "Side" ) );
  defaultsidechainSourceLabels.append( QString::fromUtf8( "Left" ) );
  defaultsidechainSourceLabels.append( QString::fromUtf8( "Right" ) );
  defaultsidechainSourceLabels.append( QString::fromUtf8( "Min" ) );
  defaultsidechainSourceLabels.append( QString::fromUtf8( "Max" ) );

  KConfigCompilerSignallingItem  *itemSidechainSourceLabels;
  KConfigBaseEE::ItemStringList  *innerItemSidechainSourceLabels;
  innerItemSidechainSourceLabels = new KConfigBaseEE::ItemStringList( currentGroup(), QStringLiteral( "sidechainSourceLabels" ), mSidechainSourceLabels, defaultsidechainSourceLabels );
  itemSidechainSourceLabels = new KConfigCompilerSignallingItem(innerItemSidechainSourceLabels, this, notifyFunction, signalSidechainSourceLabelsChanged);
  itemSidechainSourceLabels->setWriteFlags(KConfigBase::Notify);
  itemSidechainSourceLabels->setGroup(cgMultibandCompressorinstanceIndex);
  addItem( itemSidechainSourceLabels, QStringLiteral( "sidechainSourceLabels" ) );
  KConfigCompilerSignallingItem  *itemBand0SidechainSource;
  KConfigBaseEE::ItemInt  *innerItemBand0SidechainSource;
  innerItemBand0SidechainSource = new KConfigBaseEE::ItemInt( currentGroup(), QStringLiteral( "band0SidechainSource" ), mBand0SidechainSource, 0 );
  itemBand0SidechainSource = new KConfigCompilerSignallingItem(innerItemBand0SidechainSource, this, notifyFunction, signalBand0SidechainSourceChanged);
  itemBand0SidechainSource->setWriteFlags(KConfigBase::Notify);
  itemBand0SidechainSource->setGroup(cgMultibandCompressorinstanceIndex);
  addItem( itemBand0SidechainSource, QStringLiteral( "band0SidechainSource" ) );
  KConfigCompilerSignallingItem  *itemBand1SidechainSource;
  KConfigBaseEE::ItemInt  *innerItemBand1SidechainSource;
  innerItemBand1SidechainSource = new KConfigBaseEE::ItemInt( currentGroup(), QStringLiteral( "band1SidechainSource" ), mBand1SidechainSource, 0 );
  itemBand1SidechainSource = new KConfigCompilerSignallingItem(innerItemBand1SidechainSource, this, notifyFunction, signalBand1SidechainSourceChanged);
  itemBand1SidechainSource->setWriteFlags(KConfigBase::Notify);
  itemBand1SidechainSource->setGroup(cgMultibandCompressorinstanceIndex);
  addItem( itemBand1SidechainSource, QStringLiteral( "band1SidechainSource" ) );
  KConfigCompilerSignallingItem  *itemBand2SidechainSource;
  KConfigBaseEE::ItemInt  *innerItemBand2SidechainSource;
  innerItemBand2SidechainSource = new KConfigBaseEE::ItemInt( currentGroup(), QStringLiteral( "band2SidechainSource" ), mBand2SidechainSource, 0 );
  itemBand2SidechainSource = new KConfigCompilerSignallingItem(innerItemBand2SidechainSource, this, notifyFunction, signalBand2SidechainSourceChanged);
  itemBand2SidechainSource->setWriteFlags(KConfigBase::Notify);
  itemBand2SidechainSource->setGroup(cgMultibandCompressorinstanceIndex);
  addItem( itemBand2SidechainSource, QStringLiteral( "band2SidechainSource" ) );
  KConfigCompilerSignallingItem  *itemBand3SidechainSource;
  KConfigBaseEE::ItemInt  *innerItemBand3SidechainSource;
  innerItemBand3SidechainSource = new KConfigBaseEE::ItemInt( currentGroup(), QStringLiteral( "band3SidechainSource" ), mBand3SidechainSource, 0 );
  itemBand3SidechainSource = new KConfigCompilerSignallingItem(innerItemBand3SidechainSource, this, notifyFunction, signalBand3SidechainSourceChanged);
  itemBand3SidechainSource->setWriteFlags(KConfigBase::Notify);
  itemBand3SidechainSource->setGroup(cgMultibandCompressorinstanceIndex);
  addItem( itemBand3SidechainSource, QStringLiteral( "band3SidechainSource" ) );
  KConfigCompilerSignallingItem  *itemBand4SidechainSource;
  KConfigBaseEE::ItemInt  *innerItemBand4SidechainSource;
  innerItemBand4SidechainSource = new KConfigBaseEE::ItemInt( currentGroup(), QStringLiteral( "band4SidechainSource" ), mBand4SidechainSource, 0 );
  itemBand4SidechainSource = new KConfigCompilerSignallingItem(innerItemBand4SidechainSource, this, notifyFunction, signalBand4SidechainSourceChanged);
  itemBand4SidechainSource->setWriteFlags(KConfigBase::Notify);
  itemBand4SidechainSource->setGroup(cgMultibandCompressorinstanceIndex);
  addItem( itemBand4SidechainSource, QStringLiteral( "band4SidechainSource" ) );
  KConfigCompilerSignallingItem  *itemBand5SidechainSource;
  KConfigBaseEE::ItemInt  *innerItemBand5SidechainSource;
  innerItemBand5SidechainSource = new KConfigBaseEE::ItemInt( currentGroup(), QStringLiteral( "band5SidechainSource" ), mBand5SidechainSource, 0 );
  itemBand5SidechainSource = new KConfigCompilerSignallingItem(innerItemBand5SidechainSource, this, notifyFunction, signalBand5SidechainSourceChanged);
  itemBand5SidechainSource->setWriteFlags(KConfigBase::Notify);
  itemBand5SidechainSource->setGroup(cgMultibandCompressorinstanceIndex);
  addItem( itemBand5SidechainSource, QStringLiteral( "band5SidechainSource" ) );
  KConfigCompilerSignallingItem  *itemBand6SidechainSource;
  KConfigBaseEE::ItemInt  *innerItemBand6SidechainSource;
  innerItemBand6SidechainSource = new KConfigBaseEE::ItemInt( currentGroup(), QStringLiteral( "band6SidechainSource" ), mBand6SidechainSource, 0 );
  itemBand6SidechainSource = new KConfigCompilerSignallingItem(innerItemBand6SidechainSource, this, notifyFunction, signalBand6SidechainSourceChanged);
  itemBand6SidechainSource->setWriteFlags(KConfigBase::Notify);
  itemBand6SidechainSource->setGroup(cgMultibandCompressorinstanceIndex);
  addItem( itemBand6SidechainSource, QStringLiteral( "band6SidechainSource" ) );
  KConfigCompilerSignallingItem  *itemBand7SidechainSource;
  KConfigBaseEE::ItemInt  *innerItemBand7SidechainSource;
  innerItemBand7SidechainSource = new KConfigBaseEE::ItemInt( currentGroup(), QStringLiteral( "band7SidechainSource" ), mBand7SidechainSource, 0 );
  itemBand7SidechainSource = new KConfigCompilerSignallingItem(innerItemBand7SidechainSource, this, notifyFunction, signalBand7SidechainSourceChanged);
  itemBand7SidechainSource->setWriteFlags(KConfigBase::Notify);
  itemBand7SidechainSource->setGroup(cgMultibandCompressorinstanceIndex);
  addItem( itemBand7SidechainSource, QStringLiteral( "band7SidechainSource" ) );
  QStringList defaultstereoSplitSourceLabels;
  defaultstereoSplitSourceLabels.append( QString::fromUtf8( "Left/Right" ) );
  defaultstereoSplitSourceLabels.append( QString::fromUtf8( "Right/Left" ) );
  defaultstereoSplitSourceLabels.append( QString::fromUtf8( "Mid/Side" ) );
  defaultstereoSplitSourceLabels.append( QString::fromUtf8( "Side/Mid" ) );
  defaultstereoSplitSourceLabels.append( QString::fromUtf8( "Min" ) );
  defaultstereoSplitSourceLabels.append( QString::fromUtf8( "Max" ) );

  KConfigCompilerSignallingItem  *itemStereoSplitSourceLabels;
  KConfigBaseEE::ItemStringList  *innerItemStereoSplitSourceLabels;
  innerItemStereoSplitSourceLabels = new KConfigBaseEE::ItemStringList( currentGroup(), QStringLiteral( "stereoSplitSourceLabels" ), mStereoSplitSourceLabels, defaultstereoSplitSourceLabels );
  itemStereoSplitSourceLabels = new KConfigCompilerSignallingItem(innerItemStereoSplitSourceLabels, this, notifyFunction, signalStereoSplitSourceLabelsChanged);
  itemStereoSplitSourceLabels->setWriteFlags(KConfigBase::Notify);
  itemStereoSplitSourceLabels->setGroup(cgMultibandCompressorinstanceIndex);
  addItem( itemStereoSplitSourceLabels, QStringLiteral( "stereoSplitSourceLabels" ) );
  KConfigCompilerSignallingItem  *itemBand0StereoSplitSource;
  KConfigBaseEE::ItemInt  *innerItemBand0StereoSplitSource;
  innerItemBand0StereoSplitSource = new KConfigBaseEE::ItemInt( currentGroup(), QStringLiteral( "band0StereoSplitSource" ), mBand0StereoSplitSource, 0 );
  itemBand0StereoSplitSource = new KConfigCompilerSignallingItem(innerItemBand0StereoSplitSource, this, notifyFunction, signalBand0StereoSplitSourceChanged);
  itemBand0StereoSplitSource->setWriteFlags(KConfigBase::Notify);
  itemBand0StereoSplitSource->setGroup(cgMultibandCompressorinstanceIndex);
  addItem( itemBand0StereoSplitSource, QStringLiteral( "band0StereoSplitSource" ) );
  KConfigCompilerSignallingItem  *itemBand1StereoSplitSource;
  KConfigBaseEE::ItemInt  *innerItemBand1StereoSplitSource;
  innerItemBand1StereoSplitSource = new KConfigBaseEE::ItemInt( currentGroup(), QStringLiteral( "band1StereoSplitSource" ), mBand1StereoSplitSource, 0 );
  itemBand1StereoSplitSource = new KConfigCompilerSignallingItem(innerItemBand1StereoSplitSource, this, notifyFunction, signalBand1StereoSplitSourceChanged);
  itemBand1StereoSplitSource->setWriteFlags(KConfigBase::Notify);
  itemBand1StereoSplitSource->setGroup(cgMultibandCompressorinstanceIndex);
  addItem( itemBand1StereoSplitSource, QStringLiteral( "band1StereoSplitSource" ) );
  KConfigCompilerSignallingItem  *itemBand2StereoSplitSource;
  KConfigBaseEE::ItemInt  *innerItemBand2StereoSplitSource;
  innerItemBand2StereoSplitSource = new KConfigBaseEE::ItemInt( currentGroup(), QStringLiteral( "band2StereoSplitSource" ), mBand2StereoSplitSource, 0 );
  itemBand2StereoSplitSource = new KConfigCompilerSignallingItem(innerItemBand2StereoSplitSource, this, notifyFunction, signalBand2StereoSplitSourceChanged);
  itemBand2StereoSplitSource->setWriteFlags(KConfigBase::Notify);
  itemBand2StereoSplitSource->setGroup(cgMultibandCompressorinstanceIndex);
  addItem( itemBand2StereoSplitSource, QStringLiteral( "band2StereoSplitSource" ) );
  KConfigCompilerSignallingItem  *itemBand3StereoSplitSource;
  KConfigBaseEE::ItemInt  *innerItemBand3StereoSplitSource;
  innerItemBand3StereoSplitSource = new KConfigBaseEE::ItemInt( currentGroup(), QStringLiteral( "band3StereoSplitSource" ), mBand3StereoSplitSource, 0 );
  itemBand3StereoSplitSource = new KConfigCompilerSignallingItem(innerItemBand3StereoSplitSource, this, notifyFunction, signalBand3StereoSplitSourceChanged);
  itemBand3StereoSplitSource->setWriteFlags(KConfigBase::Notify);
  itemBand3StereoSplitSource->setGroup(cgMultibandCompressorinstanceIndex);
  addItem( itemBand3StereoSplitSource, QStringLiteral( "band3StereoSplitSource" ) );
  KConfigCompilerSignallingItem  *itemBand4StereoSplitSource;
  KConfigBaseEE::ItemInt  *innerItemBand4StereoSplitSource;
  innerItemBand4StereoSplitSource = new KConfigBaseEE::ItemInt( currentGroup(), QStringLiteral( "band4StereoSplitSource" ), mBand4StereoSplitSource, 0 );
  itemBand4StereoSplitSource = new KConfigCompilerSignallingItem(innerItemBand4StereoSplitSource, this, notifyFunction, signalBand4StereoSplitSourceChanged);
  itemBand4StereoSplitSource->setWriteFlags(KConfigBase::Notify);
  itemBand4StereoSplitSource->setGroup(cgMultibandCompressorinstanceIndex);
  addItem( itemBand4StereoSplitSource, QStringLiteral( "band4StereoSplitSource" ) );
  KConfigCompilerSignallingItem  *itemBand5StereoSplitSource;
  KConfigBaseEE::ItemInt  *innerItemBand5StereoSplitSource;
  innerItemBand5StereoSplitSource = new KConfigBaseEE::ItemInt( currentGroup(), QStringLiteral( "band5StereoSplitSource" ), mBand5StereoSplitSource, 0 );
  itemBand5StereoSplitSource = new KConfigCompilerSignallingItem(innerItemBand5StereoSplitSource, this, notifyFunction, signalBand5StereoSplitSourceChanged);
  itemBand5StereoSplitSource->setWriteFlags(KConfigBase::Notify);
  itemBand5StereoSplitSource->setGroup(cgMultibandCompressorinstanceIndex);
  addItem( itemBand5StereoSplitSource, QStringLiteral( "band5StereoSplitSource" ) );
  KConfigCompilerSignallingItem  *itemBand6StereoSplitSource;
  KConfigBaseEE::ItemInt  *innerItemBand6StereoSplitSource;
  innerItemBand6StereoSplitSource = new KConfigBaseEE::ItemInt( currentGroup(), QStringLiteral( "band6StereoSplitSource" ), mBand6StereoSplitSource, 0 );
  itemBand6StereoSplitSource = new KConfigCompilerSignallingItem(innerItemBand6StereoSplitSource, this, notifyFunction, signalBand6StereoSplitSourceChanged);
  itemBand6StereoSplitSource->setWriteFlags(KConfigBase::Notify);
  itemBand6StereoSplitSource->setGroup(cgMultibandCompressorinstanceIndex);
  addItem( itemBand6StereoSplitSource, QStringLiteral( "band6StereoSplitSource" ) );
  KConfigCompilerSignallingItem  *itemBand7StereoSplitSource;
  KConfigBaseEE::ItemInt  *innerItemBand7StereoSplitSource;
  innerItemBand7StereoSplitSource = new KConfigBaseEE::ItemInt( currentGroup(), QStringLiteral( "band7StereoSplitSource" ), mBand7StereoSplitSource, 0 );
  itemBand7StereoSplitSource = new KConfigCompilerSignallingItem(innerItemBand7StereoSplitSource, this, notifyFunction, signalBand7StereoSplitSourceChanged);
  itemBand7StereoSplitSource->setWriteFlags(KConfigBase::Notify);
  itemBand7StereoSplitSource->setGroup(cgMultibandCompressorinstanceIndex);
  addItem( itemBand7StereoSplitSource, QStringLiteral( "band7StereoSplitSource" ) );
  KConfigCompilerSignallingItem  *itemBand0SidechainLookahead;
  KConfigBaseEE::ItemDouble  *innerItemBand0SidechainLookahead;
  innerItemBand0SidechainLookahead = new KConfigBaseEE::ItemDouble( currentGroup(), QStringLiteral( "band0SidechainLookahead" ), mBand0SidechainLookahead, 0 );
  itemBand0SidechainLookahead = new KConfigCompilerSignallingItem(innerItemBand0SidechainLookahead, this, notifyFunction, signalBand0SidechainLookaheadChanged);
  innerItemBand0SidechainLookahead->setMinValue(0);
  innerItemBand0SidechainLookahead->setMaxValue(20);
  itemBand0SidechainLookahead->setWriteFlags(KConfigBase::Notify);
  itemBand0SidechainLookahead->setGroup(cgMultibandCompressorinstanceIndex);
  addItem( itemBand0SidechainLookahead, QStringLiteral( "band0SidechainLookahead" ) );
  KConfigCompilerSignallingItem  *itemBand1SidechainLookahead;
  KConfigBaseEE::ItemDouble  *innerItemBand1SidechainLookahead;
  innerItemBand1SidechainLookahead = new KConfigBaseEE::ItemDouble( currentGroup(), QStringLiteral( "band1SidechainLookahead" ), mBand1SidechainLookahead, 0 );
  itemBand1SidechainLookahead = new KConfigCompilerSignallingItem(innerItemBand1SidechainLookahead, this, notifyFunction, signalBand1SidechainLookaheadChanged);
  innerItemBand1SidechainLookahead->setMinValue(0);
  innerItemBand1SidechainLookahead->setMaxValue(20);
  itemBand1SidechainLookahead->setWriteFlags(KConfigBase::Notify);
  itemBand1SidechainLookahead->setGroup(cgMultibandCompressorinstanceIndex);
  addItem( itemBand1SidechainLookahead, QStringLiteral( "band1SidechainLookahead" ) );
  KConfigCompilerSignallingItem  *itemBand2SidechainLookahead;
  KConfigBaseEE::ItemDouble  *innerItemBand2SidechainLookahead;
  innerItemBand2SidechainLookahead = new KConfigBaseEE::ItemDouble( currentGroup(), QStringLiteral( "band2SidechainLookahead" ), mBand2SidechainLookahead, 0 );
  itemBand2SidechainLookahead = new KConfigCompilerSignallingItem(innerItemBand2SidechainLookahead, this, notifyFunction, signalBand2SidechainLookaheadChanged);
  innerItemBand2SidechainLookahead->setMinValue(0);
  innerItemBand2SidechainLookahead->setMaxValue(20);
  itemBand2SidechainLookahead->setWriteFlags(KConfigBase::Notify);
  itemBand2SidechainLookahead->setGroup(cgMultibandCompressorinstanceIndex);
  addItem( itemBand2SidechainLookahead, QStringLiteral( "band2SidechainLookahead" ) );
  KConfigCompilerSignallingItem  *itemBand3SidechainLookahead;
  KConfigBaseEE::ItemDouble  *innerItemBand3SidechainLookahead;
  innerItemBand3SidechainLookahead = new KConfigBaseEE::ItemDouble( currentGroup(), QStringLiteral( "band3SidechainLookahead" ), mBand3SidechainLookahead, 0 );
  itemBand3SidechainLookahead = new KConfigCompilerSignallingItem(innerItemBand3SidechainLookahead, this, notifyFunction, signalBand3SidechainLookaheadChanged);
  innerItemBand3SidechainLookahead->setMinValue(0);
  innerItemBand3SidechainLookahead->setMaxValue(20);
  itemBand3SidechainLookahead->setWriteFlags(KConfigBase::Notify);
  itemBand3SidechainLookahead->setGroup(cgMultibandCompressorinstanceIndex);
  addItem( itemBand3SidechainLookahead, QStringLiteral( "band3SidechainLookahead" ) );
  KConfigCompilerSignallingItem  *itemBand4SidechainLookahead;
  KConfigBaseEE::ItemDouble  *innerItemBand4SidechainLookahead;
  innerItemBand4SidechainLookahead = new KConfigBaseEE::ItemDouble( currentGroup(), QStringLiteral( "band4SidechainLookahead" ), mBand4SidechainLookahead, 0 );
  itemBand4SidechainLookahead = new KConfigCompilerSignallingItem(innerItemBand4SidechainLookahead, this, notifyFunction, signalBand4SidechainLookaheadChanged);
  innerItemBand4SidechainLookahead->setMinValue(0);
  innerItemBand4SidechainLookahead->setMaxValue(20);
  itemBand4SidechainLookahead->setWriteFlags(KConfigBase::Notify);
  itemBand4SidechainLookahead->setGroup(cgMultibandCompressorinstanceIndex);
  addItem( itemBand4SidechainLookahead, QStringLiteral( "band4SidechainLookahead" ) );
  KConfigCompilerSignallingItem  *itemBand5SidechainLookahead;
  KConfigBaseEE::ItemDouble  *innerItemBand5SidechainLookahead;
  innerItemBand5SidechainLookahead = new KConfigBaseEE::ItemDouble( currentGroup(), QStringLiteral( "band5SidechainLookahead" ), mBand5SidechainLookahead, 0 );
  itemBand5SidechainLookahead = new KConfigCompilerSignallingItem(innerItemBand5SidechainLookahead, this, notifyFunction, signalBand5SidechainLookaheadChanged);
  innerItemBand5SidechainLookahead->setMinValue(0);
  innerItemBand5SidechainLookahead->setMaxValue(20);
  itemBand5SidechainLookahead->setWriteFlags(KConfigBase::Notify);
  itemBand5SidechainLookahead->setGroup(cgMultibandCompressorinstanceIndex);
  addItem( itemBand5SidechainLookahead, QStringLiteral( "band5SidechainLookahead" ) );
  KConfigCompilerSignallingItem  *itemBand6SidechainLookahead;
  KConfigBaseEE::ItemDouble  *innerItemBand6SidechainLookahead;
  innerItemBand6SidechainLookahead = new KConfigBaseEE::ItemDouble( currentGroup(), QStringLiteral( "band6SidechainLookahead" ), mBand6SidechainLookahead, 0 );
  itemBand6SidechainLookahead = new KConfigCompilerSignallingItem(innerItemBand6SidechainLookahead, this, notifyFunction, signalBand6SidechainLookaheadChanged);
  innerItemBand6SidechainLookahead->setMinValue(0);
  innerItemBand6SidechainLookahead->setMaxValue(20);
  itemBand6SidechainLookahead->setWriteFlags(KConfigBase::Notify);
  itemBand6SidechainLookahead->setGroup(cgMultibandCompressorinstanceIndex);
  addItem( itemBand6SidechainLookahead, QStringLiteral( "band6SidechainLookahead" ) );
  KConfigCompilerSignallingItem  *itemBand7SidechainLookahead;
  KConfigBaseEE::ItemDouble  *innerItemBand7SidechainLookahead;
  innerItemBand7SidechainLookahead = new KConfigBaseEE::ItemDouble( currentGroup(), QStringLiteral( "band7SidechainLookahead" ), mBand7SidechainLookahead, 0 );
  itemBand7SidechainLookahead = new KConfigCompilerSignallingItem(innerItemBand7SidechainLookahead, this, notifyFunction, signalBand7SidechainLookaheadChanged);
  innerItemBand7SidechainLookahead->setMinValue(0);
  innerItemBand7SidechainLookahead->setMaxValue(20);
  itemBand7SidechainLookahead->setWriteFlags(KConfigBase::Notify);
  itemBand7SidechainLookahead->setGroup(cgMultibandCompressorinstanceIndex);
  addItem( itemBand7SidechainLookahead, QStringLiteral( "band7SidechainLookahead" ) );
  KConfigCompilerSignallingItem  *itemBand0SidechainReactivity;
  KConfigBaseEE::ItemDouble  *innerItemBand0SidechainReactivity;
  innerItemBand0SidechainReactivity = new KConfigBaseEE::ItemDouble( currentGroup(), QStringLiteral( "band0SidechainReactivity" ), mBand0SidechainReactivity, 10 );
  itemBand0SidechainReactivity = new KConfigCompilerSignallingItem(innerItemBand0SidechainReactivity, this, notifyFunction, signalBand0SidechainReactivityChanged);
  innerItemBand0SidechainReactivity->setMinValue(0);
  innerItemBand0SidechainReactivity->setMaxValue(250);
  itemBand0SidechainReactivity->setWriteFlags(KConfigBase::Notify);
  itemBand0SidechainReactivity->setGroup(cgMultibandCompressorinstanceIndex);
  addItem( itemBand0SidechainReactivity, QStringLiteral( "band0SidechainReactivity" ) );
  KConfigCompilerSignallingItem  *itemBand1SidechainReactivity;
  KConfigBaseEE::ItemDouble  *innerItemBand1SidechainReactivity;
  innerItemBand1SidechainReactivity = new KConfigBaseEE::ItemDouble( currentGroup(), QStringLiteral( "band1SidechainReactivity" ), mBand1SidechainReactivity, 10 );
  itemBand1SidechainReactivity = new KConfigCompilerSignallingItem(innerItemBand1SidechainReactivity, this, notifyFunction, signalBand1SidechainReactivityChanged);
  innerItemBand1SidechainReactivity->setMinValue(0);
  innerItemBand1SidechainReactivity->setMaxValue(250);
  itemBand1SidechainReactivity->setWriteFlags(KConfigBase::Notify);
  itemBand1SidechainReactivity->setGroup(cgMultibandCompressorinstanceIndex);
  addItem( itemBand1SidechainReactivity, QStringLiteral( "band1SidechainReactivity" ) );
  KConfigCompilerSignallingItem  *itemBand2SidechainReactivity;
  KConfigBaseEE::ItemDouble  *innerItemBand2SidechainReactivity;
  innerItemBand2SidechainReactivity = new KConfigBaseEE::ItemDouble( currentGroup(), QStringLiteral( "band2SidechainReactivity" ), mBand2SidechainReactivity, 10 );
  itemBand2SidechainReactivity = new KConfigCompilerSignallingItem(innerItemBand2SidechainReactivity, this, notifyFunction, signalBand2SidechainReactivityChanged);
  innerItemBand2SidechainReactivity->setMinValue(0);
  innerItemBand2SidechainReactivity->setMaxValue(250);
  itemBand2SidechainReactivity->setWriteFlags(KConfigBase::Notify);
  itemBand2SidechainReactivity->setGroup(cgMultibandCompressorinstanceIndex);
  addItem( itemBand2SidechainReactivity, QStringLiteral( "band2SidechainReactivity" ) );
  KConfigCompilerSignallingItem  *itemBand3SidechainReactivity;
  KConfigBaseEE::ItemDouble  *innerItemBand3SidechainReactivity;
  innerItemBand3SidechainReactivity = new KConfigBaseEE::ItemDouble( currentGroup(), QStringLiteral( "band3SidechainReactivity" ), mBand3SidechainReactivity, 10 );
  itemBand3SidechainReactivity = new KConfigCompilerSignallingItem(innerItemBand3SidechainReactivity, this, notifyFunction, signalBand3SidechainReactivityChanged);
  innerItemBand3SidechainReactivity->setMinValue(0);
  innerItemBand3SidechainReactivity->setMaxValue(250);
  itemBand3SidechainReactivity->setWriteFlags(KConfigBase::Notify);
  itemBand3SidechainReactivity->setGroup(cgMultibandCompressorinstanceIndex);
  addItem( itemBand3SidechainReactivity, QStringLiteral( "band3SidechainReactivity" ) );
  KConfigCompilerSignallingItem  *itemBand4SidechainReactivity;
  KConfigBaseEE::ItemDouble  *innerItemBand4SidechainReactivity;
  innerItemBand4SidechainReactivity = new KConfigBaseEE::ItemDouble( currentGroup(), QStringLiteral( "band4SidechainReactivity" ), mBand4SidechainReactivity, 10 );
  itemBand4SidechainReactivity = new KConfigCompilerSignallingItem(innerItemBand4SidechainReactivity, this, notifyFunction, signalBand4SidechainReactivityChanged);
  innerItemBand4SidechainReactivity->setMinValue(0);
  innerItemBand4SidechainReactivity->setMaxValue(250);
  itemBand4SidechainReactivity->setWriteFlags(KConfigBase::Notify);
  itemBand4SidechainReactivity->setGroup(cgMultibandCompressorinstanceIndex);
  addItem( itemBand4SidechainReactivity, QStringLiteral( "band4SidechainReactivity" ) );
  KConfigCompilerSignallingItem  *itemBand5SidechainReactivity;
  KConfigBaseEE::ItemDouble  *innerItemBand5SidechainReactivity;
  innerItemBand5SidechainReactivity = new KConfigBaseEE::ItemDouble( currentGroup(), QStringLiteral( "band5SidechainReactivity" ), mBand5SidechainReactivity, 10 );
  itemBand5SidechainReactivity = new KConfigCompilerSignallingItem(innerItemBand5SidechainReactivity, this, notifyFunction, signalBand5SidechainReactivityChanged);
  innerItemBand5SidechainReactivity->setMinValue(0);
  innerItemBand5SidechainReactivity->setMaxValue(250);
  itemBand5SidechainReactivity->setWriteFlags(KConfigBase::Notify);
  itemBand5SidechainReactivity->setGroup(cgMultibandCompressorinstanceIndex);
  addItem( itemBand5SidechainReactivity, QStringLiteral( "band5SidechainReactivity" ) );
  KConfigCompilerSignallingItem  *itemBand6SidechainReactivity;
  KConfigBaseEE::ItemDouble  *innerItemBand6SidechainReactivity;
  innerItemBand6SidechainReactivity = new KConfigBaseEE::ItemDouble( currentGroup(), QStringLiteral( "band6SidechainReactivity" ), mBand6SidechainReactivity, 10 );
  itemBand6SidechainReactivity = new KConfigCompilerSignallingItem(innerItemBand6SidechainReactivity, this, notifyFunction, signalBand6SidechainReactivityChanged);
  innerItemBand6SidechainReactivity->setMinValue(0);
  innerItemBand6SidechainReactivity->setMaxValue(250);
  itemBand6SidechainReactivity->setWriteFlags(KConfigBase::Notify);
  itemBand6SidechainReactivity->setGroup(cgMultibandCompressorinstanceIndex);
  addItem( itemBand6SidechainReactivity, QStringLiteral( "band6SidechainReactivity" ) );
  KConfigCompilerSignallingItem  *itemBand7SidechainReactivity;
  KConfigBaseEE::ItemDouble  *innerItemBand7SidechainReactivity;
  innerItemBand7SidechainReactivity = new KConfigBaseEE::ItemDouble( currentGroup(), QStringLiteral( "band7SidechainReactivity" ), mBand7SidechainReactivity, 10 );
  itemBand7SidechainReactivity = new KConfigCompilerSignallingItem(innerItemBand7SidechainReactivity, this, notifyFunction, signalBand7SidechainReactivityChanged);
  innerItemBand7SidechainReactivity->setMinValue(0);
  innerItemBand7SidechainReactivity->setMaxValue(250);
  itemBand7SidechainReactivity->setWriteFlags(KConfigBase::Notify);
  itemBand7SidechainReactivity->setGroup(cgMultibandCompressorinstanceIndex);
  addItem( itemBand7SidechainReactivity, QStringLiteral( "band7SidechainReactivity" ) );
  KConfigCompilerSignallingItem  *itemBand0SidechainPreamp;
  KConfigBaseEE::ItemDouble  *innerItemBand0SidechainPreamp;
  innerItemBand0SidechainPreamp = new KConfigBaseEE::ItemDouble( currentGroup(), QStringLiteral( "band0SidechainPreamp" ), mBand0SidechainPreamp, 0 );
  itemBand0SidechainPreamp = new KConfigCompilerSignallingItem(innerItemBand0SidechainPreamp, this, notifyFunction, signalBand0SidechainPreampChanged);
  innerItemBand0SidechainPreamp->setMinValue(-80.01);
  innerItemBand0SidechainPreamp->setMaxValue(40);
  itemBand0SidechainPreamp->setWriteFlags(KConfigBase::Notify);
  itemBand0SidechainPreamp->setGroup(cgMultibandCompressorinstanceIndex);
  addItem( itemBand0SidechainPreamp, QStringLiteral( "band0SidechainPreamp" ) );
  KConfigCompilerSignallingItem  *itemBand1SidechainPreamp;
  KConfigBaseEE::ItemDouble  *innerItemBand1SidechainPreamp;
  innerItemBand1SidechainPreamp = new KConfigBaseEE::ItemDouble( currentGroup(), QStringLiteral( "band1SidechainPreamp" ), mBand1SidechainPreamp, 0 );
  itemBand1SidechainPreamp = new KConfigCompilerSignallingItem(innerItemBand1SidechainPreamp, this, notifyFunction, signalBand1SidechainPreampChanged);
  innerItemBand1SidechainPreamp->setMinValue(-80.01);
  innerItemBand1SidechainPreamp->setMaxValue(40);
  itemBand1SidechainPreamp->setWriteFlags(KConfigBase::Notify);
  itemBand1SidechainPreamp->setGroup(cgMultibandCompressorinstanceIndex);
  addItem( itemBand1SidechainPreamp, QStringLiteral( "band1SidechainPreamp" ) );
  KConfigCompilerSignallingItem  *itemBand2SidechainPreamp;
  KConfigBaseEE::ItemDouble  *innerItemBand2SidechainPreamp;
  innerItemBand2SidechainPreamp = new KConfigBaseEE::ItemDouble( currentGroup(), QStringLiteral( "band2SidechainPreamp" ), mBand2SidechainPreamp, 0 );
  itemBand2SidechainPreamp = new KConfigCompilerSignallingItem(innerItemBand2SidechainPreamp, this, notifyFunction, signalBand2SidechainPreampChanged);
  innerItemBand2SidechainPreamp->setMinValue(-80.01);
  innerItemBand2SidechainPreamp->setMaxValue(40);
  itemBand2SidechainPreamp->setWriteFlags(KConfigBase::Notify);
  itemBand2SidechainPreamp->setGroup(cgMultibandCompressorinstanceIndex);
  addItem( itemBand2SidechainPreamp, QStringLiteral( "band2SidechainPreamp" ) );
  KConfigCompilerSignallingItem  *itemBand3SidechainPreamp;
  KConfigBaseEE::ItemDouble  *innerItemBand3SidechainPreamp;
  innerItemBand3SidechainPreamp = new KConfigBaseEE::ItemDouble( currentGroup(), QStringLiteral( "band3SidechainPreamp" ), mBand3SidechainPreamp, 0 );
  itemBand3SidechainPreamp = new KConfigCompilerSignallingItem(innerItemBand3SidechainPreamp, this, notifyFunction, signalBand3SidechainPreampChanged);
  innerItemBand3SidechainPreamp->setMinValue(-80.01);
  innerItemBand3SidechainPreamp->setMaxValue(40);
  itemBand3SidechainPreamp->setWriteFlags(KConfigBase::Notify);
  itemBand3SidechainPreamp->setGroup(cgMultibandCompressorinstanceIndex);
  addItem( itemBand3SidechainPreamp, QStringLiteral( "band3SidechainPreamp" ) );
  KConfigCompilerSignallingItem  *itemBand4SidechainPreamp;
  KConfigBaseEE::ItemDouble  *innerItemBand4SidechainPreamp;
  innerItemBand4SidechainPreamp = new KConfigBaseEE::ItemDouble( currentGroup(), QStringLiteral( "band4SidechainPreamp" ), mBand4SidechainPreamp, 0 );
  itemBand4SidechainPreamp = new KConfigCompilerSignallingItem(innerItemBand4SidechainPreamp, this, notifyFunction, signalBand4SidechainPreampChanged);
  innerItemBand4SidechainPreamp->setMinValue(-80.01);
  innerItemBand4SidechainPreamp->setMaxValue(40);
  itemBand4SidechainPreamp->setWriteFlags(KConfigBase::Notify);
  itemBand4SidechainPreamp->setGroup(cgMultibandCompressorinstanceIndex);
  addItem( itemBand4SidechainPreamp, QStringLiteral( "band4SidechainPreamp" ) );
  KConfigCompilerSignallingItem  *itemBand5SidechainPreamp;
  KConfigBaseEE::ItemDouble  *innerItemBand5SidechainPreamp;
  innerItemBand5SidechainPreamp = new KConfigBaseEE::ItemDouble( currentGroup(), QStringLiteral( "band5SidechainPreamp" ), mBand5SidechainPreamp, 0 );
  itemBand5SidechainPreamp = new KConfigCompilerSignallingItem(innerItemBand5SidechainPreamp, this, notifyFunction, signalBand5SidechainPreampChanged);
  innerItemBand5SidechainPreamp->setMinValue(-80.01);
  innerItemBand5SidechainPreamp->setMaxValue(40);
  itemBand5SidechainPreamp->setWriteFlags(KConfigBase::Notify);
  itemBand5SidechainPreamp->setGroup(cgMultibandCompressorinstanceIndex);
  addItem( itemBand5SidechainPreamp, QStringLiteral( "band5SidechainPreamp" ) );
  KConfigCompilerSignallingItem  *itemBand6SidechainPreamp;
  KConfigBaseEE::ItemDouble  *innerItemBand6SidechainPreamp;
  innerItemBand6SidechainPreamp = new KConfigBaseEE::ItemDouble( currentGroup(), QStringLiteral( "band6SidechainPreamp" ), mBand6SidechainPreamp, 0 );
  itemBand6SidechainPreamp = new KConfigCompilerSignallingItem(innerItemBand6SidechainPreamp, this, notifyFunction, signalBand6SidechainPreampChanged);
  innerItemBand6SidechainPreamp->setMinValue(-80.01);
  innerItemBand6SidechainPreamp->setMaxValue(40);
  itemBand6SidechainPreamp->setWriteFlags(KConfigBase::Notify);
  itemBand6SidechainPreamp->setGroup(cgMultibandCompressorinstanceIndex);
  addItem( itemBand6SidechainPreamp, QStringLiteral( "band6SidechainPreamp" ) );
  KConfigCompilerSignallingItem  *itemBand7SidechainPreamp;
  KConfigBaseEE::ItemDouble  *innerItemBand7SidechainPreamp;
  innerItemBand7SidechainPreamp = new KConfigBaseEE::ItemDouble( currentGroup(), QStringLiteral( "band7SidechainPreamp" ), mBand7SidechainPreamp, 0 );
  itemBand7SidechainPreamp = new KConfigCompilerSignallingItem(innerItemBand7SidechainPreamp, this, notifyFunction, signalBand7SidechainPreampChanged);
  innerItemBand7SidechainPreamp->setMinValue(-80.01);
  innerItemBand7SidechainPreamp->setMaxValue(40);
  itemBand7SidechainPreamp->setWriteFlags(KConfigBase::Notify);
  itemBand7SidechainPreamp->setGroup(cgMultibandCompressorinstanceIndex);
  addItem( itemBand7SidechainPreamp, QStringLiteral( "band7SidechainPreamp" ) );
  KConfigCompilerSignallingItem  *itemBand0SidechainCustomLowcutFilter;
  KConfigBaseEE::ItemBool  *innerItemBand0SidechainCustomLowcutFilter;
  innerItemBand0SidechainCustomLowcutFilter = new KConfigBaseEE::ItemBool( currentGroup(), QStringLiteral( "band0SidechainCustomLowcutFilter" ), mBand0SidechainCustomLowcutFilter, false );
  itemBand0SidechainCustomLowcutFilter = new KConfigCompilerSignallingItem(innerItemBand0SidechainCustomLowcutFilter, this, notifyFunction, signalBand0SidechainCustomLowcutFilterChanged);
  itemBand0SidechainCustomLowcutFilter->setWriteFlags(KConfigBase::Notify);
  itemBand0SidechainCustomLowcutFilter->setGroup(cgMultibandCompressorinstanceIndex);
  addItem( itemBand0SidechainCustomLowcutFilter, QStringLiteral( "band0SidechainCustomLowcutFilter" ) );
  KConfigCompilerSignallingItem  *itemBand1SidechainCustomLowcutFilter;
  KConfigBaseEE::ItemBool  *innerItemBand1SidechainCustomLowcutFilter;
  innerItemBand1SidechainCustomLowcutFilter = new KConfigBaseEE::ItemBool( currentGroup(), QStringLiteral( "band1SidechainCustomLowcutFilter" ), mBand1SidechainCustomLowcutFilter, false );
  itemBand1SidechainCustomLowcutFilter = new KConfigCompilerSignallingItem(innerItemBand1SidechainCustomLowcutFilter, this, notifyFunction, signalBand1SidechainCustomLowcutFilterChanged);
  itemBand1SidechainCustomLowcutFilter->setWriteFlags(KConfigBase::Notify);
  itemBand1SidechainCustomLowcutFilter->setGroup(cgMultibandCompressorinstanceIndex);
  addItem( itemBand1SidechainCustomLowcutFilter, QStringLiteral( "band1SidechainCustomLowcutFilter" ) );
  KConfigCompilerSignallingItem  *itemBand2SidechainCustomLowcutFilter;
  KConfigBaseEE::ItemBool  *innerItemBand2SidechainCustomLowcutFilter;
  innerItemBand2SidechainCustomLowcutFilter = new KConfigBaseEE::ItemBool( currentGroup(), QStringLiteral( "band2SidechainCustomLowcutFilter" ), mBand2SidechainCustomLowcutFilter, false );
  itemBand2SidechainCustomLowcutFilter = new KConfigCompilerSignallingItem(innerItemBand2SidechainCustomLowcutFilter, this, notifyFunction, signalBand2SidechainCustomLowcutFilterChanged);
  itemBand2SidechainCustomLowcutFilter->setWriteFlags(KConfigBase::Notify);
  itemBand2SidechainCustomLowcutFilter->setGroup(cgMultibandCompressorinstanceIndex);
  addItem( itemBand2SidechainCustomLowcutFilter, QStringLiteral( "band2SidechainCustomLowcutFilter" ) );
  KConfigCompilerSignallingItem  *itemBand3SidechainCustomLowcutFilter;
  KConfigBaseEE::ItemBool  *innerItemBand3SidechainCustomLowcutFilter;
  innerItemBand3SidechainCustomLowcutFilter = new KConfigBaseEE::ItemBool( currentGroup(), QStringLiteral( "band3SidechainCustomLowcutFilter" ), mBand3SidechainCustomLowcutFilter, false );
  itemBand3SidechainCustomLowcutFilter = new KConfigCompilerSignallingItem(innerItemBand3SidechainCustomLowcutFilter, this, notifyFunction, signalBand3SidechainCustomLowcutFilterChanged);
  itemBand3SidechainCustomLowcutFilter->setWriteFlags(KConfigBase::Notify);
  itemBand3SidechainCustomLowcutFilter->setGroup(cgMultibandCompressorinstanceIndex);
  addItem( itemBand3SidechainCustomLowcutFilter, QStringLiteral( "band3SidechainCustomLowcutFilter" ) );
  KConfigCompilerSignallingItem  *itemBand4SidechainCustomLowcutFilter;
  KConfigBaseEE::ItemBool  *innerItemBand4SidechainCustomLowcutFilter;
  innerItemBand4SidechainCustomLowcutFilter = new KConfigBaseEE::ItemBool( currentGroup(), QStringLiteral( "band4SidechainCustomLowcutFilter" ), mBand4SidechainCustomLowcutFilter, false );
  itemBand4SidechainCustomLowcutFilter = new KConfigCompilerSignallingItem(innerItemBand4SidechainCustomLowcutFilter, this, notifyFunction, signalBand4SidechainCustomLowcutFilterChanged);
  itemBand4SidechainCustomLowcutFilter->setWriteFlags(KConfigBase::Notify);
  itemBand4SidechainCustomLowcutFilter->setGroup(cgMultibandCompressorinstanceIndex);
  addItem( itemBand4SidechainCustomLowcutFilter, QStringLiteral( "band4SidechainCustomLowcutFilter" ) );
  KConfigCompilerSignallingItem  *itemBand5SidechainCustomLowcutFilter;
  KConfigBaseEE::ItemBool  *innerItemBand5SidechainCustomLowcutFilter;
  innerItemBand5SidechainCustomLowcutFilter = new KConfigBaseEE::ItemBool( currentGroup(), QStringLiteral( "band5SidechainCustomLowcutFilter" ), mBand5SidechainCustomLowcutFilter, false );
  itemBand5SidechainCustomLowcutFilter = new KConfigCompilerSignallingItem(innerItemBand5SidechainCustomLowcutFilter, this, notifyFunction, signalBand5SidechainCustomLowcutFilterChanged);
  itemBand5SidechainCustomLowcutFilter->setWriteFlags(KConfigBase::Notify);
  itemBand5SidechainCustomLowcutFilter->setGroup(cgMultibandCompressorinstanceIndex);
  addItem( itemBand5SidechainCustomLowcutFilter, QStringLiteral( "band5SidechainCustomLowcutFilter" ) );
  KConfigCompilerSignallingItem  *itemBand6SidechainCustomLowcutFilter;
  KConfigBaseEE::ItemBool  *innerItemBand6SidechainCustomLowcutFilter;
  innerItemBand6SidechainCustomLowcutFilter = new KConfigBaseEE::ItemBool( currentGroup(), QStringLiteral( "band6SidechainCustomLowcutFilter" ), mBand6SidechainCustomLowcutFilter, false );
  itemBand6SidechainCustomLowcutFilter = new KConfigCompilerSignallingItem(innerItemBand6SidechainCustomLowcutFilter, this, notifyFunction, signalBand6SidechainCustomLowcutFilterChanged);
  itemBand6SidechainCustomLowcutFilter->setWriteFlags(KConfigBase::Notify);
  itemBand6SidechainCustomLowcutFilter->setGroup(cgMultibandCompressorinstanceIndex);
  addItem( itemBand6SidechainCustomLowcutFilter, QStringLiteral( "band6SidechainCustomLowcutFilter" ) );
  KConfigCompilerSignallingItem  *itemBand7SidechainCustomLowcutFilter;
  KConfigBaseEE::ItemBool  *innerItemBand7SidechainCustomLowcutFilter;
  innerItemBand7SidechainCustomLowcutFilter = new KConfigBaseEE::ItemBool( currentGroup(), QStringLiteral( "band7SidechainCustomLowcutFilter" ), mBand7SidechainCustomLowcutFilter, false );
  itemBand7SidechainCustomLowcutFilter = new KConfigCompilerSignallingItem(innerItemBand7SidechainCustomLowcutFilter, this, notifyFunction, signalBand7SidechainCustomLowcutFilterChanged);
  itemBand7SidechainCustomLowcutFilter->setWriteFlags(KConfigBase::Notify);
  itemBand7SidechainCustomLowcutFilter->setGroup(cgMultibandCompressorinstanceIndex);
  addItem( itemBand7SidechainCustomLowcutFilter, QStringLiteral( "band7SidechainCustomLowcutFilter" ) );
  KConfigCompilerSignallingItem  *itemBand0SidechainCustomHighcutFilter;
  KConfigBaseEE::ItemBool  *innerItemBand0SidechainCustomHighcutFilter;
  innerItemBand0SidechainCustomHighcutFilter = new KConfigBaseEE::ItemBool( currentGroup(), QStringLiteral( "band0SidechainCustomHighcutFilter" ), mBand0SidechainCustomHighcutFilter, false );
  itemBand0SidechainCustomHighcutFilter = new KConfigCompilerSignallingItem(innerItemBand0SidechainCustomHighcutFilter, this, notifyFunction, signalBand0SidechainCustomHighcutFilterChanged);
  itemBand0SidechainCustomHighcutFilter->setWriteFlags(KConfigBase::Notify);
  itemBand0SidechainCustomHighcutFilter->setGroup(cgMultibandCompressorinstanceIndex);
  addItem( itemBand0SidechainCustomHighcutFilter, QStringLiteral( "band0SidechainCustomHighcutFilter" ) );
  KConfigCompilerSignallingItem  *itemBand1SidechainCustomHighcutFilter;
  KConfigBaseEE::ItemBool  *innerItemBand1SidechainCustomHighcutFilter;
  innerItemBand1SidechainCustomHighcutFilter = new KConfigBaseEE::ItemBool( currentGroup(), QStringLiteral( "band1SidechainCustomHighcutFilter" ), mBand1SidechainCustomHighcutFilter, false );
  itemBand1SidechainCustomHighcutFilter = new KConfigCompilerSignallingItem(innerItemBand1SidechainCustomHighcutFilter, this, notifyFunction, signalBand1SidechainCustomHighcutFilterChanged);
  itemBand1SidechainCustomHighcutFilter->setWriteFlags(KConfigBase::Notify);
  itemBand1SidechainCustomHighcutFilter->setGroup(cgMultibandCompressorinstanceIndex);
  addItem( itemBand1SidechainCustomHighcutFilter, QStringLiteral( "band1SidechainCustomHighcutFilter" ) );
  KConfigCompilerSignallingItem  *itemBand2SidechainCustomHighcutFilter;
  KConfigBaseEE::ItemBool  *innerItemBand2SidechainCustomHighcutFilter;
  innerItemBand2SidechainCustomHighcutFilter = new KConfigBaseEE::ItemBool( currentGroup(), QStringLiteral( "band2SidechainCustomHighcutFilter" ), mBand2SidechainCustomHighcutFilter, false );
  itemBand2SidechainCustomHighcutFilter = new KConfigCompilerSignallingItem(innerItemBand2SidechainCustomHighcutFilter, this, notifyFunction, signalBand2SidechainCustomHighcutFilterChanged);
  itemBand2SidechainCustomHighcutFilter->setWriteFlags(KConfigBase::Notify);
  itemBand2SidechainCustomHighcutFilter->setGroup(cgMultibandCompressorinstanceIndex);
  addItem( itemBand2SidechainCustomHighcutFilter, QStringLiteral( "band2SidechainCustomHighcutFilter" ) );
  KConfigCompilerSignallingItem  *itemBand3SidechainCustomHighcutFilter;
  KConfigBaseEE::ItemBool  *innerItemBand3SidechainCustomHighcutFilter;
  innerItemBand3SidechainCustomHighcutFilter = new KConfigBaseEE::ItemBool( currentGroup(), QStringLiteral( "band3SidechainCustomHighcutFilter" ), mBand3SidechainCustomHighcutFilter, false );
  itemBand3SidechainCustomHighcutFilter = new KConfigCompilerSignallingItem(innerItemBand3SidechainCustomHighcutFilter, this, notifyFunction, signalBand3SidechainCustomHighcutFilterChanged);
  itemBand3SidechainCustomHighcutFilter->setWriteFlags(KConfigBase::Notify);
  itemBand3SidechainCustomHighcutFilter->setGroup(cgMultibandCompressorinstanceIndex);
  addItem( itemBand3SidechainCustomHighcutFilter, QStringLiteral( "band3SidechainCustomHighcutFilter" ) );
  KConfigCompilerSignallingItem  *itemBand4SidechainCustomHighcutFilter;
  KConfigBaseEE::ItemBool  *innerItemBand4SidechainCustomHighcutFilter;
  innerItemBand4SidechainCustomHighcutFilter = new KConfigBaseEE::ItemBool( currentGroup(), QStringLiteral( "band4SidechainCustomHighcutFilter" ), mBand4SidechainCustomHighcutFilter, false );
  itemBand4SidechainCustomHighcutFilter = new KConfigCompilerSignallingItem(innerItemBand4SidechainCustomHighcutFilter, this, notifyFunction, signalBand4SidechainCustomHighcutFilterChanged);
  itemBand4SidechainCustomHighcutFilter->setWriteFlags(KConfigBase::Notify);
  itemBand4SidechainCustomHighcutFilter->setGroup(cgMultibandCompressorinstanceIndex);
  addItem( itemBand4SidechainCustomHighcutFilter, QStringLiteral( "band4SidechainCustomHighcutFilter" ) );
  KConfigCompilerSignallingItem  *itemBand5SidechainCustomHighcutFilter;
  KConfigBaseEE::ItemBool  *innerItemBand5SidechainCustomHighcutFilter;
  innerItemBand5SidechainCustomHighcutFilter = new KConfigBaseEE::ItemBool( currentGroup(), QStringLiteral( "band5SidechainCustomHighcutFilter" ), mBand5SidechainCustomHighcutFilter, false );
  itemBand5SidechainCustomHighcutFilter = new KConfigCompilerSignallingItem(innerItemBand5SidechainCustomHighcutFilter, this, notifyFunction, signalBand5SidechainCustomHighcutFilterChanged);
  itemBand5SidechainCustomHighcutFilter->setWriteFlags(KConfigBase::Notify);
  itemBand5SidechainCustomHighcutFilter->setGroup(cgMultibandCompressorinstanceIndex);
  addItem( itemBand5SidechainCustomHighcutFilter, QStringLiteral( "band5SidechainCustomHighcutFilter" ) );
  KConfigCompilerSignallingItem  *itemBand6SidechainCustomHighcutFilter;
  KConfigBaseEE::ItemBool  *innerItemBand6SidechainCustomHighcutFilter;
  innerItemBand6SidechainCustomHighcutFilter = new KConfigBaseEE::ItemBool( currentGroup(), QStringLiteral( "band6SidechainCustomHighcutFilter" ), mBand6SidechainCustomHighcutFilter, false );
  itemBand6SidechainCustomHighcutFilter = new KConfigCompilerSignallingItem(innerItemBand6SidechainCustomHighcutFilter, this, notifyFunction, signalBand6SidechainCustomHighcutFilterChanged);
  itemBand6SidechainCustomHighcutFilter->setWriteFlags(KConfigBase::Notify);
  itemBand6SidechainCustomHighcutFilter->setGroup(cgMultibandCompressorinstanceIndex);
  addItem( itemBand6SidechainCustomHighcutFilter, QStringLiteral( "band6SidechainCustomHighcutFilter" ) );
  KConfigCompilerSignallingItem  *itemBand7SidechainCustomHighcutFilter;
  KConfigBaseEE::ItemBool  *innerItemBand7SidechainCustomHighcutFilter;
  innerItemBand7SidechainCustomHighcutFilter = new KConfigBaseEE::ItemBool( currentGroup(), QStringLiteral( "band7SidechainCustomHighcutFilter" ), mBand7SidechainCustomHighcutFilter, false );
  itemBand7SidechainCustomHighcutFilter = new KConfigCompilerSignallingItem(innerItemBand7SidechainCustomHighcutFilter, this, notifyFunction, signalBand7SidechainCustomHighcutFilterChanged);
  itemBand7SidechainCustomHighcutFilter->setWriteFlags(KConfigBase::Notify);
  itemBand7SidechainCustomHighcutFilter->setGroup(cgMultibandCompressorinstanceIndex);
  addItem( itemBand7SidechainCustomHighcutFilter, QStringLiteral( "band7SidechainCustomHighcutFilter" ) );
  KConfigCompilerSignallingItem  *itemBand0SidechainLowcutFrequency;
  KConfigBaseEE::ItemDouble  *innerItemBand0SidechainLowcutFrequency;
  innerItemBand0SidechainLowcutFrequency = new KConfigBaseEE::ItemDouble( currentGroup(), QStringLiteral( "band0SidechainLowcutFrequency" ), mBand0SidechainLowcutFrequency, 10 );
  itemBand0SidechainLowcutFrequency = new KConfigCompilerSignallingItem(innerItemBand0SidechainLowcutFrequency, this, notifyFunction, signalBand0SidechainLowcutFrequencyChanged);
  innerItemBand0SidechainLowcutFrequency->setMinValue(10);
  innerItemBand0SidechainLowcutFrequency->setMaxValue(20000);
  itemBand0SidechainLowcutFrequency->setWriteFlags(KConfigBase::Notify);
  itemBand0SidechainLowcutFrequency->setGroup(cgMultibandCompressorinstanceIndex);
  addItem( itemBand0SidechainLowcutFrequency, QStringLiteral( "band0SidechainLowcutFrequency" ) );
  KConfigCompilerSignallingItem  *itemBand1SidechainLowcutFrequency;
  KConfigBaseEE::ItemDouble  *innerItemBand1SidechainLowcutFrequency;
  innerItemBand1SidechainLowcutFrequency = new KConfigBaseEE::ItemDouble( currentGroup(), QStringLiteral( "band1SidechainLowcutFrequency" ), mBand1SidechainLowcutFrequency, 500 );
  itemBand1SidechainLowcutFrequency = new KConfigCompilerSignallingItem(innerItemBand1SidechainLowcutFrequency, this, notifyFunction, signalBand1SidechainLowcutFrequencyChanged);
  innerItemBand1SidechainLowcutFrequency->setMinValue(10);
  innerItemBand1SidechainLowcutFrequency->setMaxValue(20000);
  itemBand1SidechainLowcutFrequency->setWriteFlags(KConfigBase::Notify);
  itemBand1SidechainLowcutFrequency->setGroup(cgMultibandCompressorinstanceIndex);
  addItem( itemBand1SidechainLowcutFrequency, QStringLiteral( "band1SidechainLowcutFrequency" ) );
  KConfigCompilerSignallingItem  *itemBand2SidechainLowcutFrequency;
  KConfigBaseEE::ItemDouble  *innerItemBand2SidechainLowcutFrequency;
  innerItemBand2SidechainLowcutFrequency = new KConfigBaseEE::ItemDouble( currentGroup(), QStringLiteral( "band2SidechainLowcutFrequency" ), mBand2SidechainLowcutFrequency, 1000 );
  itemBand2SidechainLowcutFrequency = new KConfigCompilerSignallingItem(innerItemBand2SidechainLowcutFrequency, this, notifyFunction, signalBand2SidechainLowcutFrequencyChanged);
  innerItemBand2SidechainLowcutFrequency->setMinValue(10);
  innerItemBand2SidechainLowcutFrequency->setMaxValue(20000);
  itemBand2SidechainLowcutFrequency->setWriteFlags(KConfigBase::Notify);
  itemBand2SidechainLowcutFrequency->setGroup(cgMultibandCompressorinstanceIndex);
  addItem( itemBand2SidechainLowcutFrequency, QStringLiteral( "band2SidechainLowcutFrequency" ) );
  KConfigCompilerSignallingItem  *itemBand3SidechainLowcutFrequency;
  KConfigBaseEE::ItemDouble  *innerItemBand3SidechainLowcutFrequency;
  innerItemBand3SidechainLowcutFrequency = new KConfigBaseEE::ItemDouble( currentGroup(), QStringLiteral( "band3SidechainLowcutFrequency" ), mBand3SidechainLowcutFrequency, 2000 );
  itemBand3SidechainLowcutFrequency = new KConfigCompilerSignallingItem(innerItemBand3SidechainLowcutFrequency, this, notifyFunction, signalBand3SidechainLowcutFrequencyChanged);
  innerItemBand3SidechainLowcutFrequency->setMinValue(10);
  innerItemBand3SidechainLowcutFrequency->setMaxValue(20000);
  itemBand3SidechainLowcutFrequency->setWriteFlags(KConfigBase::Notify);
  itemBand3SidechainLowcutFrequency->setGroup(cgMultibandCompressorinstanceIndex);
  addItem( itemBand3SidechainLowcutFrequency, QStringLiteral( "band3SidechainLowcutFrequency" ) );
  KConfigCompilerSignallingItem  *itemBand4SidechainLowcutFrequency;
  KConfigBaseEE::ItemDouble  *innerItemBand4SidechainLowcutFrequency;
  innerItemBand4SidechainLowcutFrequency = new KConfigBaseEE::ItemDouble( currentGroup(), QStringLiteral( "band4SidechainLowcutFrequency" ), mBand4SidechainLowcutFrequency, 4000 );
  itemBand4SidechainLowcutFrequency = new KConfigCompilerSignallingItem(innerItemBand4SidechainLowcutFrequency, this, notifyFunction, signalBand4SidechainLowcutFrequencyChanged);
  innerItemBand4SidechainLowcutFrequency->setMinValue(10);
  innerItemBand4SidechainLowcutFrequency->setMaxValue(20000);
  itemBand4SidechainLowcutFrequency->setWriteFlags(KConfigBase::Notify);
  itemBand4SidechainLowcutFrequency->setGroup(cgMultibandCompressorinstanceIndex);
  addItem( itemBand4SidechainLowcutFrequency, QStringLiteral( "band4SidechainLowcutFrequency" ) );
  KConfigCompilerSignallingItem  *itemBand5SidechainLowcutFrequency;
  KConfigBaseEE::ItemDouble  *innerItemBand5SidechainLowcutFrequency;
  innerItemBand5SidechainLowcutFrequency = new KConfigBaseEE::ItemDouble( currentGroup(), QStringLiteral( "band5SidechainLowcutFrequency" ), mBand5SidechainLowcutFrequency, 8000 );
  itemBand5SidechainLowcutFrequency = new KConfigCompilerSignallingItem(innerItemBand5SidechainLowcutFrequency, this, notifyFunction, signalBand5SidechainLowcutFrequencyChanged);
  innerItemBand5SidechainLowcutFrequency->setMinValue(10);
  innerItemBand5SidechainLowcutFrequency->setMaxValue(20000);
  itemBand5SidechainLowcutFrequency->setWriteFlags(KConfigBase::Notify);
  itemBand5SidechainLowcutFrequency->setGroup(cgMultibandCompressorinstanceIndex);
  addItem( itemBand5SidechainLowcutFrequency, QStringLiteral( "band5SidechainLowcutFrequency" ) );
  KConfigCompilerSignallingItem  *itemBand6SidechainLowcutFrequency;
  KConfigBaseEE::ItemDouble  *innerItemBand6SidechainLowcutFrequency;
  innerItemBand6SidechainLowcutFrequency = new KConfigBaseEE::ItemDouble( currentGroup(), QStringLiteral( "band6SidechainLowcutFrequency" ), mBand6SidechainLowcutFrequency, 12000 );
  itemBand6SidechainLowcutFrequency = new KConfigCompilerSignallingItem(innerItemBand6SidechainLowcutFrequency, this, notifyFunction, signalBand6SidechainLowcutFrequencyChanged);
  innerItemBand6SidechainLowcutFrequency->setMinValue(10);
  innerItemBand6SidechainLowcutFrequency->setMaxValue(20000);
  itemBand6SidechainLowcutFrequency->setWriteFlags(KConfigBase::Notify);
  itemBand6SidechainLowcutFrequency->setGroup(cgMultibandCompressorinstanceIndex);
  addItem( itemBand6SidechainLowcutFrequency, QStringLiteral( "band6SidechainLowcutFrequency" ) );
  KConfigCompilerSignallingItem  *itemBand7SidechainLowcutFrequency;
  KConfigBaseEE::ItemDouble  *innerItemBand7SidechainLowcutFrequency;
  innerItemBand7SidechainLowcutFrequency = new KConfigBaseEE::ItemDouble( currentGroup(), QStringLiteral( "band7SidechainLowcutFrequency" ), mBand7SidechainLowcutFrequency, 16000 );
  itemBand7SidechainLowcutFrequency = new KConfigCompilerSignallingItem(innerItemBand7SidechainLowcutFrequency, this, notifyFunction, signalBand7SidechainLowcutFrequencyChanged);
  innerItemBand7SidechainLowcutFrequency->setMinValue(10);
  innerItemBand7SidechainLowcutFrequency->setMaxValue(20000);
  itemBand7SidechainLowcutFrequency->setWriteFlags(KConfigBase::Notify);
  itemBand7SidechainLowcutFrequency->setGroup(cgMultibandCompressorinstanceIndex);
  addItem( itemBand7SidechainLowcutFrequency, QStringLiteral( "band7SidechainLowcutFrequency" ) );
  KConfigCompilerSignallingItem  *itemBand0SidechainHighcutFrequency;
  KConfigBaseEE::ItemDouble  *innerItemBand0SidechainHighcutFrequency;
  innerItemBand0SidechainHighcutFrequency = new KConfigBaseEE::ItemDouble( currentGroup(), QStringLiteral( "band0SidechainHighcutFrequency" ), mBand0SidechainHighcutFrequency, 500 );
  itemBand0SidechainHighcutFrequency = new KConfigCompilerSignallingItem(innerItemBand0SidechainHighcutFrequency, this, notifyFunction, signalBand0SidechainHighcutFrequencyChanged);
  innerItemBand0SidechainHighcutFrequency->setMinValue(10);
  innerItemBand0SidechainHighcutFrequency->setMaxValue(20000);
  itemBand0SidechainHighcutFrequency->setWriteFlags(KConfigBase::Notify);
  itemBand0SidechainHighcutFrequency->setGroup(cgMultibandCompressorinstanceIndex);
  addItem( itemBand0SidechainHighcutFrequency, QStringLiteral( "band0SidechainHighcutFrequency" ) );
  KConfigCompilerSignallingItem  *itemBand1SidechainHighcutFrequency;
  KConfigBaseEE::ItemDouble  *innerItemBand1SidechainHighcutFrequency;
  innerItemBand1SidechainHighcutFrequency = new KConfigBaseEE::ItemDouble( currentGroup(), QStringLiteral( "band1SidechainHighcutFrequency" ), mBand1SidechainHighcutFrequency, 1000 );
  itemBand1SidechainHighcutFrequency = new KConfigCompilerSignallingItem(innerItemBand1SidechainHighcutFrequency, this, notifyFunction, signalBand1SidechainHighcutFrequencyChanged);
  innerItemBand1SidechainHighcutFrequency->setMinValue(10);
  innerItemBand1SidechainHighcutFrequency->setMaxValue(20000);
  itemBand1SidechainHighcutFrequency->setWriteFlags(KConfigBase::Notify);
  itemBand1SidechainHighcutFrequency->setGroup(cgMultibandCompressorinstanceIndex);
  addItem( itemBand1SidechainHighcutFrequency, QStringLiteral( "band1SidechainHighcutFrequency" ) );
  KConfigCompilerSignallingItem  *itemBand2SidechainHighcutFrequency;
  KConfigBaseEE::ItemDouble  *innerItemBand2SidechainHighcutFrequency;
  innerItemBand2SidechainHighcutFrequency = new KConfigBaseEE::ItemDouble( currentGroup(), QStringLiteral( "band2SidechainHighcutFrequency" ), mBand2SidechainHighcutFrequency, 2000 );
  itemBand2SidechainHighcutFrequency = new KConfigCompilerSignallingItem(innerItemBand2SidechainHighcutFrequency, this, notifyFunction, signalBand2SidechainHighcutFrequencyChanged);
  innerItemBand2SidechainHighcutFrequency->setMinValue(10);
  innerItemBand2SidechainHighcutFrequency->setMaxValue(20000);
  itemBand2SidechainHighcutFrequency->setWriteFlags(KConfigBase::Notify);
  itemBand2SidechainHighcutFrequency->setGroup(cgMultibandCompressorinstanceIndex);
  addItem( itemBand2SidechainHighcutFrequency, QStringLiteral( "band2SidechainHighcutFrequency" ) );
  KConfigCompilerSignallingItem  *itemBand3SidechainHighcutFrequency;
  KConfigBaseEE::ItemDouble  *innerItemBand3SidechainHighcutFrequency;
  innerItemBand3SidechainHighcutFrequency = new KConfigBaseEE::ItemDouble( currentGroup(), QStringLiteral( "band3SidechainHighcutFrequency" ), mBand3SidechainHighcutFrequency, 4000 );
  itemBand3SidechainHighcutFrequency = new KConfigCompilerSignallingItem(innerItemBand3SidechainHighcutFrequency, this, notifyFunction, signalBand3SidechainHighcutFrequencyChanged);
  innerItemBand3SidechainHighcutFrequency->setMinValue(10);
  innerItemBand3SidechainHighcutFrequency->setMaxValue(20000);
  itemBand3SidechainHighcutFrequency->setWriteFlags(KConfigBase::Notify);
  itemBand3SidechainHighcutFrequency->setGroup(cgMultibandCompressorinstanceIndex);
  addItem( itemBand3SidechainHighcutFrequency, QStringLiteral( "band3SidechainHighcutFrequency" ) );
  KConfigCompilerSignallingItem  *itemBand4SidechainHighcutFrequency;
  KConfigBaseEE::ItemDouble  *innerItemBand4SidechainHighcutFrequency;
  innerItemBand4SidechainHighcutFrequency = new KConfigBaseEE::ItemDouble( currentGroup(), QStringLiteral( "band4SidechainHighcutFrequency" ), mBand4SidechainHighcutFrequency, 8000 );
  itemBand4SidechainHighcutFrequency = new KConfigCompilerSignallingItem(innerItemBand4SidechainHighcutFrequency, this, notifyFunction, signalBand4SidechainHighcutFrequencyChanged);
  innerItemBand4SidechainHighcutFrequency->setMinValue(10);
  innerItemBand4SidechainHighcutFrequency->setMaxValue(20000);
  itemBand4SidechainHighcutFrequency->setWriteFlags(KConfigBase::Notify);
  itemBand4SidechainHighcutFrequency->setGroup(cgMultibandCompressorinstanceIndex);
  addItem( itemBand4SidechainHighcutFrequency, QStringLiteral( "band4SidechainHighcutFrequency" ) );
  KConfigCompilerSignallingItem  *itemBand5SidechainHighcutFrequency;
  KConfigBaseEE::ItemDouble  *innerItemBand5SidechainHighcutFrequency;
  innerItemBand5SidechainHighcutFrequency = new KConfigBaseEE::ItemDouble( currentGroup(), QStringLiteral( "band5SidechainHighcutFrequency" ), mBand5SidechainHighcutFrequency, 12000 );
  itemBand5SidechainHighcutFrequency = new KConfigCompilerSignallingItem(innerItemBand5SidechainHighcutFrequency, this, notifyFunction, signalBand5SidechainHighcutFrequencyChanged);
  innerItemBand5SidechainHighcutFrequency->setMinValue(10);
  innerItemBand5SidechainHighcutFrequency->setMaxValue(20000);
  itemBand5SidechainHighcutFrequency->setWriteFlags(KConfigBase::Notify);
  itemBand5SidechainHighcutFrequency->setGroup(cgMultibandCompressorinstanceIndex);
  addItem( itemBand5SidechainHighcutFrequency, QStringLiteral( "band5SidechainHighcutFrequency" ) );
  KConfigCompilerSignallingItem  *itemBand6SidechainHighcutFrequency;
  KConfigBaseEE::ItemDouble  *innerItemBand6SidechainHighcutFrequency;
  innerItemBand6SidechainHighcutFrequency = new KConfigBaseEE::ItemDouble( currentGroup(), QStringLiteral( "band6SidechainHighcutFrequency" ), mBand6SidechainHighcutFrequency, 16000 );
  itemBand6SidechainHighcutFrequency = new KConfigCompilerSignallingItem(innerItemBand6SidechainHighcutFrequency, this, notifyFunction, signalBand6SidechainHighcutFrequencyChanged);
  innerItemBand6SidechainHighcutFrequency->setMinValue(10);
  innerItemBand6SidechainHighcutFrequency->setMaxValue(20000);
  itemBand6SidechainHighcutFrequency->setWriteFlags(KConfigBase::Notify);
  itemBand6SidechainHighcutFrequency->setGroup(cgMultibandCompressorinstanceIndex);
  addItem( itemBand6SidechainHighcutFrequency, QStringLiteral( "band6SidechainHighcutFrequency" ) );
  KConfigCompilerSignallingItem  *itemBand7SidechainHighcutFrequency;
  KConfigBaseEE::ItemDouble  *innerItemBand7SidechainHighcutFrequency;
  innerItemBand7SidechainHighcutFrequency = new KConfigBaseEE::ItemDouble( currentGroup(), QStringLiteral( "band7SidechainHighcutFrequency" ), mBand7SidechainHighcutFrequency, 20000 );
  itemBand7SidechainHighcutFrequency = new KConfigCompilerSignallingItem(innerItemBand7SidechainHighcutFrequency, this, notifyFunction, signalBand7SidechainHighcutFrequencyChanged);
  innerItemBand7SidechainHighcutFrequency->setMinValue(10);
  innerItemBand7SidechainHighcutFrequency->setMaxValue(20000);
  itemBand7SidechainHighcutFrequency->setWriteFlags(KConfigBase::Notify);
  itemBand7SidechainHighcutFrequency->setGroup(cgMultibandCompressorinstanceIndex);
  addItem( itemBand7SidechainHighcutFrequency, QStringLiteral( "band7SidechainHighcutFrequency" ) );
  QStringList defaultcompressionModeLabels;
  defaultcompressionModeLabels.append( QString::fromUtf8( "Downward" ) );
  defaultcompressionModeLabels.append( QString::fromUtf8( "Upward" ) );
  defaultcompressionModeLabels.append( QString::fromUtf8( "Boosting" ) );

  KConfigCompilerSignallingItem  *itemCompressionModeLabels;
  KConfigBaseEE::ItemStringList  *innerItemCompressionModeLabels;
  innerItemCompressionModeLabels = new KConfigBaseEE::ItemStringList( currentGroup(), QStringLiteral( "compressionModeLabels" ), mCompressionModeLabels, defaultcompressionModeLabels );
  itemCompressionModeLabels = new KConfigCompilerSignallingItem(innerItemCompressionModeLabels, this, notifyFunction, signalCompressionModeLabelsChanged);
  itemCompressionModeLabels->setWriteFlags(KConfigBase::Notify);
  itemCompressionModeLabels->setGroup(cgMultibandCompressorinstanceIndex);
  addItem( itemCompressionModeLabels, QStringLiteral( "compressionModeLabels" ) );
  KConfigCompilerSignallingItem  *itemBand0CompressionMode;
  KConfigBaseEE::ItemInt  *innerItemBand0CompressionMode;
  innerItemBand0CompressionMode = new KConfigBaseEE::ItemInt( currentGroup(), QStringLiteral( "band0CompressionMode" ), mBand0CompressionMode, 0 );
  itemBand0CompressionMode = new KConfigCompilerSignallingItem(innerItemBand0CompressionMode, this, notifyFunction, signalBand0CompressionModeChanged);
  itemBand0CompressionMode->setWriteFlags(KConfigBase::Notify);
  itemBand0CompressionMode->setGroup(cgMultibandCompressorinstanceIndex);
  addItem( itemBand0CompressionMode, QStringLiteral( "band0CompressionMode" ) );
  KConfigCompilerSignallingItem  *itemBand1CompressionMode;
  KConfigBaseEE::ItemInt  *innerItemBand1CompressionMode;
  innerItemBand1CompressionMode = new KConfigBaseEE::ItemInt( currentGroup(), QStringLiteral( "band1CompressionMode" ), mBand1CompressionMode, 0 );
  itemBand1CompressionMode = new KConfigCompilerSignallingItem(innerItemBand1CompressionMode, this, notifyFunction, signalBand1CompressionModeChanged);
  itemBand1CompressionMode->setWriteFlags(KConfigBase::Notify);
  itemBand1CompressionMode->setGroup(cgMultibandCompressorinstanceIndex);
  addItem( itemBand1CompressionMode, QStringLiteral( "band1CompressionMode" ) );
  KConfigCompilerSignallingItem  *itemBand2CompressionMode;
  KConfigBaseEE::ItemInt  *innerItemBand2CompressionMode;
  innerItemBand2CompressionMode = new KConfigBaseEE::ItemInt( currentGroup(), QStringLiteral( "band2CompressionMode" ), mBand2CompressionMode, 0 );
  itemBand2CompressionMode = new KConfigCompilerSignallingItem(innerItemBand2CompressionMode, this, notifyFunction, signalBand2CompressionModeChanged);
  itemBand2CompressionMode->setWriteFlags(KConfigBase::Notify);
  itemBand2CompressionMode->setGroup(cgMultibandCompressorinstanceIndex);
  addItem( itemBand2CompressionMode, QStringLiteral( "band2CompressionMode" ) );
  KConfigCompilerSignallingItem  *itemBand3CompressionMode;
  KConfigBaseEE::ItemInt  *innerItemBand3CompressionMode;
  innerItemBand3CompressionMode = new KConfigBaseEE::ItemInt( currentGroup(), QStringLiteral( "band3CompressionMode" ), mBand3CompressionMode, 0 );
  itemBand3CompressionMode = new KConfigCompilerSignallingItem(innerItemBand3CompressionMode, this, notifyFunction, signalBand3CompressionModeChanged);
  itemBand3CompressionMode->setWriteFlags(KConfigBase::Notify);
  itemBand3CompressionMode->setGroup(cgMultibandCompressorinstanceIndex);
  addItem( itemBand3CompressionMode, QStringLiteral( "band3CompressionMode" ) );
  KConfigCompilerSignallingItem  *itemBand4CompressionMode;
  KConfigBaseEE::ItemInt  *innerItemBand4CompressionMode;
  innerItemBand4CompressionMode = new KConfigBaseEE::ItemInt( currentGroup(), QStringLiteral( "band4CompressionMode" ), mBand4CompressionMode, 0 );
  itemBand4CompressionMode = new KConfigCompilerSignallingItem(innerItemBand4CompressionMode, this, notifyFunction, signalBand4CompressionModeChanged);
  itemBand4CompressionMode->setWriteFlags(KConfigBase::Notify);
  itemBand4CompressionMode->setGroup(cgMultibandCompressorinstanceIndex);
  addItem( itemBand4CompressionMode, QStringLiteral( "band4CompressionMode" ) );
  KConfigCompilerSignallingItem  *itemBand5CompressionMode;
  KConfigBaseEE::ItemInt  *innerItemBand5CompressionMode;
  innerItemBand5CompressionMode = new KConfigBaseEE::ItemInt( currentGroup(), QStringLiteral( "band5CompressionMode" ), mBand5CompressionMode, 0 );
  itemBand5CompressionMode = new KConfigCompilerSignallingItem(innerItemBand5CompressionMode, this, notifyFunction, signalBand5CompressionModeChanged);
  itemBand5CompressionMode->setWriteFlags(KConfigBase::Notify);
  itemBand5CompressionMode->setGroup(cgMultibandCompressorinstanceIndex);
  addItem( itemBand5CompressionMode, QStringLiteral( "band5CompressionMode" ) );
  KConfigCompilerSignallingItem  *itemBand6CompressionMode;
  KConfigBaseEE::ItemInt  *innerItemBand6CompressionMode;
  innerItemBand6CompressionMode = new KConfigBaseEE::ItemInt( currentGroup(), QStringLiteral( "band6CompressionMode" ), mBand6CompressionMode, 0 );
  itemBand6CompressionMode = new KConfigCompilerSignallingItem(innerItemBand6CompressionMode, this, notifyFunction, signalBand6CompressionModeChanged);
  itemBand6CompressionMode->setWriteFlags(KConfigBase::Notify);
  itemBand6CompressionMode->setGroup(cgMultibandCompressorinstanceIndex);
  addItem( itemBand6CompressionMode, QStringLiteral( "band6CompressionMode" ) );
  KConfigCompilerSignallingItem  *itemBand7CompressionMode;
  KConfigBaseEE::ItemInt  *innerItemBand7CompressionMode;
  innerItemBand7CompressionMode = new KConfigBaseEE::ItemInt( currentGroup(), QStringLiteral( "band7CompressionMode" ), mBand7CompressionMode, 0 );
  itemBand7CompressionMode = new KConfigCompilerSignallingItem(innerItemBand7CompressionMode, this, notifyFunction, signalBand7CompressionModeChanged);
  itemBand7CompressionMode->setWriteFlags(KConfigBase::Notify);
  itemBand7CompressionMode->setGroup(cgMultibandCompressorinstanceIndex);
  addItem( itemBand7CompressionMode, QStringLiteral( "band7CompressionMode" ) );
  KConfigCompilerSignallingItem  *itemBand0CompressorEnable;
  KConfigBaseEE::ItemBool  *innerItemBand0CompressorEnable;
  innerItemBand0CompressorEnable = new KConfigBaseEE::ItemBool( currentGroup(), QStringLiteral( "band0CompressorEnable" ), mBand0CompressorEnable, true );
  itemBand0CompressorEnable = new KConfigCompilerSignallingItem(innerItemBand0CompressorEnable, this, notifyFunction, signalBand0CompressorEnableChanged);
  itemBand0CompressorEnable->setWriteFlags(KConfigBase::Notify);
  itemBand0CompressorEnable->setGroup(cgMultibandCompressorinstanceIndex);
  addItem( itemBand0CompressorEnable, QStringLiteral( "band0CompressorEnable" ) );
  KConfigCompilerSignallingItem  *itemBand1CompressorEnable;
  KConfigBaseEE::ItemBool  *innerItemBand1CompressorEnable;
  innerItemBand1CompressorEnable = new KConfigBaseEE::ItemBool( currentGroup(), QStringLiteral( "band1CompressorEnable" ), mBand1CompressorEnable, true );
  itemBand1CompressorEnable = new KConfigCompilerSignallingItem(innerItemBand1CompressorEnable, this, notifyFunction, signalBand1CompressorEnableChanged);
  itemBand1CompressorEnable->setWriteFlags(KConfigBase::Notify);
  itemBand1CompressorEnable->setGroup(cgMultibandCompressorinstanceIndex);
  addItem( itemBand1CompressorEnable, QStringLiteral( "band1CompressorEnable" ) );
  KConfigCompilerSignallingItem  *itemBand2CompressorEnable;
  KConfigBaseEE::ItemBool  *innerItemBand2CompressorEnable;
  innerItemBand2CompressorEnable = new KConfigBaseEE::ItemBool( currentGroup(), QStringLiteral( "band2CompressorEnable" ), mBand2CompressorEnable, true );
  itemBand2CompressorEnable = new KConfigCompilerSignallingItem(innerItemBand2CompressorEnable, this, notifyFunction, signalBand2CompressorEnableChanged);
  itemBand2CompressorEnable->setWriteFlags(KConfigBase::Notify);
  itemBand2CompressorEnable->setGroup(cgMultibandCompressorinstanceIndex);
  addItem( itemBand2CompressorEnable, QStringLiteral( "band2CompressorEnable" ) );
  KConfigCompilerSignallingItem  *itemBand3CompressorEnable;
  KConfigBaseEE::ItemBool  *innerItemBand3CompressorEnable;
  innerItemBand3CompressorEnable = new KConfigBaseEE::ItemBool( currentGroup(), QStringLiteral( "band3CompressorEnable" ), mBand3CompressorEnable, true );
  itemBand3CompressorEnable = new KConfigCompilerSignallingItem(innerItemBand3CompressorEnable, this, notifyFunction, signalBand3CompressorEnableChanged);
  itemBand3CompressorEnable->setWriteFlags(KConfigBase::Notify);
  itemBand3CompressorEnable->setGroup(cgMultibandCompressorinstanceIndex);
  addItem( itemBand3CompressorEnable, QStringLiteral( "band3CompressorEnable" ) );
  KConfigCompilerSignallingItem  *itemBand4CompressorEnable;
  KConfigBaseEE::ItemBool  *innerItemBand4CompressorEnable;
  innerItemBand4CompressorEnable = new KConfigBaseEE::ItemBool( currentGroup(), QStringLiteral( "band4CompressorEnable" ), mBand4CompressorEnable, true );
  itemBand4CompressorEnable = new KConfigCompilerSignallingItem(innerItemBand4CompressorEnable, this, notifyFunction, signalBand4CompressorEnableChanged);
  itemBand4CompressorEnable->setWriteFlags(KConfigBase::Notify);
  itemBand4CompressorEnable->setGroup(cgMultibandCompressorinstanceIndex);
  addItem( itemBand4CompressorEnable, QStringLiteral( "band4CompressorEnable" ) );
  KConfigCompilerSignallingItem  *itemBand5CompressorEnable;
  KConfigBaseEE::ItemBool  *innerItemBand5CompressorEnable;
  innerItemBand5CompressorEnable = new KConfigBaseEE::ItemBool( currentGroup(), QStringLiteral( "band5CompressorEnable" ), mBand5CompressorEnable, true );
  itemBand5CompressorEnable = new KConfigCompilerSignallingItem(innerItemBand5CompressorEnable, this, notifyFunction, signalBand5CompressorEnableChanged);
  itemBand5CompressorEnable->setWriteFlags(KConfigBase::Notify);
  itemBand5CompressorEnable->setGroup(cgMultibandCompressorinstanceIndex);
  addItem( itemBand5CompressorEnable, QStringLiteral( "band5CompressorEnable" ) );
  KConfigCompilerSignallingItem  *itemBand6CompressorEnable;
  KConfigBaseEE::ItemBool  *innerItemBand6CompressorEnable;
  innerItemBand6CompressorEnable = new KConfigBaseEE::ItemBool( currentGroup(), QStringLiteral( "band6CompressorEnable" ), mBand6CompressorEnable, true );
  itemBand6CompressorEnable = new KConfigCompilerSignallingItem(innerItemBand6CompressorEnable, this, notifyFunction, signalBand6CompressorEnableChanged);
  itemBand6CompressorEnable->setWriteFlags(KConfigBase::Notify);
  itemBand6CompressorEnable->setGroup(cgMultibandCompressorinstanceIndex);
  addItem( itemBand6CompressorEnable, QStringLiteral( "band6CompressorEnable" ) );
  KConfigCompilerSignallingItem  *itemBand7CompressorEnable;
  KConfigBaseEE::ItemBool  *innerItemBand7CompressorEnable;
  innerItemBand7CompressorEnable = new KConfigBaseEE::ItemBool( currentGroup(), QStringLiteral( "band7CompressorEnable" ), mBand7CompressorEnable, true );
  itemBand7CompressorEnable = new KConfigCompilerSignallingItem(innerItemBand7CompressorEnable, this, notifyFunction, signalBand7CompressorEnableChanged);
  itemBand7CompressorEnable->setWriteFlags(KConfigBase::Notify);
  itemBand7CompressorEnable->setGroup(cgMultibandCompressorinstanceIndex);
  addItem( itemBand7CompressorEnable, QStringLiteral( "band7CompressorEnable" ) );
  KConfigCompilerSignallingItem  *itemBand0Solo;
  KConfigBaseEE::ItemBool  *innerItemBand0Solo;
  innerItemBand0Solo = new KConfigBaseEE::ItemBool( currentGroup(), QStringLiteral( "band0Solo" ), mBand0Solo, false );
  itemBand0Solo = new KConfigCompilerSignallingItem(innerItemBand0Solo, this, notifyFunction, signalBand0SoloChanged);
  itemBand0Solo->setWriteFlags(KConfigBase::Notify);
  itemBand0Solo->setGroup(cgMultibandCompressorinstanceIndex);
  addItem( itemBand0Solo, QStringLiteral( "band0Solo" ) );
  KConfigCompilerSignallingItem  *itemBand1Solo;
  KConfigBaseEE::ItemBool  *innerItemBand1Solo;
  innerItemBand1Solo = new KConfigBaseEE::ItemBool( currentGroup(), QStringLiteral( "band1Solo" ), mBand1Solo, false );
  itemBand1Solo = new KConfigCompilerSignallingItem(innerItemBand1Solo, this, notifyFunction, signalBand1SoloChanged);
  itemBand1Solo->setWriteFlags(KConfigBase::Notify);
  itemBand1Solo->setGroup(cgMultibandCompressorinstanceIndex);
  addItem( itemBand1Solo, QStringLiteral( "band1Solo" ) );
  KConfigCompilerSignallingItem  *itemBand2Solo;
  KConfigBaseEE::ItemBool  *innerItemBand2Solo;
  innerItemBand2Solo = new KConfigBaseEE::ItemBool( currentGroup(), QStringLiteral( "band2Solo" ), mBand2Solo, false );
  itemBand2Solo = new KConfigCompilerSignallingItem(innerItemBand2Solo, this, notifyFunction, signalBand2SoloChanged);
  itemBand2Solo->setWriteFlags(KConfigBase::Notify);
  itemBand2Solo->setGroup(cgMultibandCompressorinstanceIndex);
  addItem( itemBand2Solo, QStringLiteral( "band2Solo" ) );
  KConfigCompilerSignallingItem  *itemBand3Solo;
  KConfigBaseEE::ItemBool  *innerItemBand3Solo;
  innerItemBand3Solo = new KConfigBaseEE::ItemBool( currentGroup(), QStringLiteral( "band3Solo" ), mBand3Solo, false );
  itemBand3Solo = new KConfigCompilerSignallingItem(innerItemBand3Solo, this, notifyFunction, signalBand3SoloChanged);
  itemBand3Solo->setWriteFlags(KConfigBase::Notify);
  itemBand3Solo->setGroup(cgMultibandCompressorinstanceIndex);
  addItem( itemBand3Solo, QStringLiteral( "band3Solo" ) );
  KConfigCompilerSignallingItem  *itemBand4Solo;
  KConfigBaseEE::ItemBool  *innerItemBand4Solo;
  innerItemBand4Solo = new KConfigBaseEE::ItemBool( currentGroup(), QStringLiteral( "band4Solo" ), mBand4Solo, false );
  itemBand4Solo = new KConfigCompilerSignallingItem(innerItemBand4Solo, this, notifyFunction, signalBand4SoloChanged);
  itemBand4Solo->setWriteFlags(KConfigBase::Notify);
  itemBand4Solo->setGroup(cgMultibandCompressorinstanceIndex);
  addItem( itemBand4Solo, QStringLiteral( "band4Solo" ) );
  KConfigCompilerSignallingItem  *itemBand5Solo;
  KConfigBaseEE::ItemBool  *innerItemBand5Solo;
  innerItemBand5Solo = new KConfigBaseEE::ItemBool( currentGroup(), QStringLiteral( "band5Solo" ), mBand5Solo, false );
  itemBand5Solo = new KConfigCompilerSignallingItem(innerItemBand5Solo, this, notifyFunction, signalBand5SoloChanged);
  itemBand5Solo->setWriteFlags(KConfigBase::Notify);
  itemBand5Solo->setGroup(cgMultibandCompressorinstanceIndex);
  addItem( itemBand5Solo, QStringLiteral( "band5Solo" ) );
  KConfigCompilerSignallingItem  *itemBand6Solo;
  KConfigBaseEE::ItemBool  *innerItemBand6Solo;
  innerItemBand6Solo = new KConfigBaseEE::ItemBool( currentGroup(), QStringLiteral( "band6Solo" ), mBand6Solo, false );
  itemBand6Solo = new KConfigCompilerSignallingItem(innerItemBand6Solo, this, notifyFunction, signalBand6SoloChanged);
  itemBand6Solo->setWriteFlags(KConfigBase::Notify);
  itemBand6Solo->setGroup(cgMultibandCompressorinstanceIndex);
  addItem( itemBand6Solo, QStringLiteral( "band6Solo" ) );
  KConfigCompilerSignallingItem  *itemBand7Solo;
  KConfigBaseEE::ItemBool  *innerItemBand7Solo;
  innerItemBand7Solo = new KConfigBaseEE::ItemBool( currentGroup(), QStringLiteral( "band7Solo" ), mBand7Solo, false );
  itemBand7Solo = new KConfigCompilerSignallingItem(innerItemBand7Solo, this, notifyFunction, signalBand7SoloChanged);
  itemBand7Solo->setWriteFlags(KConfigBase::Notify);
  itemBand7Solo->setGroup(cgMultibandCompressorinstanceIndex);
  addItem( itemBand7Solo, QStringLiteral( "band7Solo" ) );
  KConfigCompilerSignallingItem  *itemBand0Mute;
  KConfigBaseEE::ItemBool  *innerItemBand0Mute;
  innerItemBand0Mute = new KConfigBaseEE::ItemBool( currentGroup(), QStringLiteral( "band0Mute" ), mBand0Mute, false );
  itemBand0Mute = new KConfigCompilerSignallingItem(innerItemBand0Mute, this, notifyFunction, signalBand0MuteChanged);
  itemBand0Mute->setWriteFlags(KConfigBase::Notify);
  itemBand0Mute->setGroup(cgMultibandCompressorinstanceIndex);
  addItem( itemBand0Mute, QStringLiteral( "band0Mute" ) );
  KConfigCompilerSignallingItem  *itemBand1Mute;
  KConfigBaseEE::ItemBool  *innerItemBand1Mute;
  innerItemBand1Mute = new KConfigBaseEE::ItemBool( currentGroup(), QStringLiteral( "band1Mute" ), mBand1Mute, false );
  itemBand1Mute = new KConfigCompilerSignallingItem(innerItemBand1Mute, this, notifyFunction, signalBand1MuteChanged);
  itemBand1Mute->setWriteFlags(KConfigBase::Notify);
  itemBand1Mute->setGroup(cgMultibandCompressorinstanceIndex);
  addItem( itemBand1Mute, QStringLiteral( "band1Mute" ) );
  KConfigCompilerSignallingItem  *itemBand2Mute;
  KConfigBaseEE::ItemBool  *innerItemBand2Mute;
  innerItemBand2Mute = new KConfigBaseEE::ItemBool( currentGroup(), QStringLiteral( "band2Mute" ), mBand2Mute, false );
  itemBand2Mute = new KConfigCompilerSignallingItem(innerItemBand2Mute, this, notifyFunction, signalBand2MuteChanged);
  itemBand2Mute->setWriteFlags(KConfigBase::Notify);
  itemBand2Mute->setGroup(cgMultibandCompressorinstanceIndex);
  addItem( itemBand2Mute, QStringLiteral( "band2Mute" ) );
  KConfigCompilerSignallingItem  *itemBand3Mute;
  KConfigBaseEE::ItemBool  *innerItemBand3Mute;
  innerItemBand3Mute = new KConfigBaseEE::ItemBool( currentGroup(), QStringLiteral( "band3Mute" ), mBand3Mute, false );
  itemBand3Mute = new KConfigCompilerSignallingItem(innerItemBand3Mute, this, notifyFunction, signalBand3MuteChanged);
  itemBand3Mute->setWriteFlags(KConfigBase::Notify);
  itemBand3Mute->setGroup(cgMultibandCompressorinstanceIndex);
  addItem( itemBand3Mute, QStringLiteral( "band3Mute" ) );
  KConfigCompilerSignallingItem  *itemBand4Mute;
  KConfigBaseEE::ItemBool  *innerItemBand4Mute;
  innerItemBand4Mute = new KConfigBaseEE::ItemBool( currentGroup(), QStringLiteral( "band4Mute" ), mBand4Mute, false );
  itemBand4Mute = new KConfigCompilerSignallingItem(innerItemBand4Mute, this, notifyFunction, signalBand4MuteChanged);
  itemBand4Mute->setWriteFlags(KConfigBase::Notify);
  itemBand4Mute->setGroup(cgMultibandCompressorinstanceIndex);
  addItem( itemBand4Mute, QStringLiteral( "band4Mute" ) );
  KConfigCompilerSignallingItem  *itemBand5Mute;
  KConfigBaseEE::ItemBool  *innerItemBand5Mute;
  innerItemBand5Mute = new KConfigBaseEE::ItemBool( currentGroup(), QStringLiteral( "band5Mute" ), mBand5Mute, false );
  itemBand5Mute = new KConfigCompilerSignallingItem(innerItemBand5Mute, this, notifyFunction, signalBand5MuteChanged);
  itemBand5Mute->setWriteFlags(KConfigBase::Notify);
  itemBand5Mute->setGroup(cgMultibandCompressorinstanceIndex);
  addItem( itemBand5Mute, QStringLiteral( "band5Mute" ) );
  KConfigCompilerSignallingItem  *itemBand6Mute;
  KConfigBaseEE::ItemBool  *innerItemBand6Mute;
  innerItemBand6Mute = new KConfigBaseEE::ItemBool( currentGroup(), QStringLiteral( "band6Mute" ), mBand6Mute, false );
  itemBand6Mute = new KConfigCompilerSignallingItem(innerItemBand6Mute, this, notifyFunction, signalBand6MuteChanged);
  itemBand6Mute->setWriteFlags(KConfigBase::Notify);
  itemBand6Mute->setGroup(cgMultibandCompressorinstanceIndex);
  addItem( itemBand6Mute, QStringLiteral( "band6Mute" ) );
  KConfigCompilerSignallingItem  *itemBand7Mute;
  KConfigBaseEE::ItemBool  *innerItemBand7Mute;
  innerItemBand7Mute = new KConfigBaseEE::ItemBool( currentGroup(), QStringLiteral( "band7Mute" ), mBand7Mute, false );
  itemBand7Mute = new KConfigCompilerSignallingItem(innerItemBand7Mute, this, notifyFunction, signalBand7MuteChanged);
  itemBand7Mute->setWriteFlags(KConfigBase::Notify);
  itemBand7Mute->setGroup(cgMultibandCompressorinstanceIndex);
  addItem( itemBand7Mute, QStringLiteral( "band7Mute" ) );
  KConfigCompilerSignallingItem  *itemBand0AttackThreshold;
  KConfigBaseEE::ItemDouble  *innerItemBand0AttackThreshold;
  innerItemBand0AttackThreshold = new KConfigBaseEE::ItemDouble( currentGroup(), QStringLiteral( "band0AttackThreshold" ), mBand0AttackThreshold, -12 );
  itemBand0AttackThreshold = new KConfigCompilerSignallingItem(innerItemBand0AttackThreshold, this, notifyFunction, signalBand0AttackThresholdChanged);
  innerItemBand0AttackThreshold->setMinValue(-60);
  innerItemBand0AttackThreshold->setMaxValue(0);
  itemBand0AttackThreshold->setWriteFlags(KConfigBase::Notify);
  itemBand0AttackThreshold->setGroup(cgMultibandCompressorinstanceIndex);
  addItem( itemBand0AttackThreshold, QStringLiteral( "band0AttackThreshold" ) );
  KConfigCompilerSignallingItem  *itemBand1AttackThreshold;
  KConfigBaseEE::ItemDouble  *innerItemBand1AttackThreshold;
  innerItemBand1AttackThreshold = new KConfigBaseEE::ItemDouble( currentGroup(), QStringLiteral( "band1AttackThreshold" ), mBand1AttackThreshold, -12 );
  itemBand1AttackThreshold = new KConfigCompilerSignallingItem(innerItemBand1AttackThreshold, this, notifyFunction, signalBand1AttackThresholdChanged);
  innerItemBand1AttackThreshold->setMinValue(-60);
  innerItemBand1AttackThreshold->setMaxValue(0);
  itemBand1AttackThreshold->setWriteFlags(KConfigBase::Notify);
  itemBand1AttackThreshold->setGroup(cgMultibandCompressorinstanceIndex);
  addItem( itemBand1AttackThreshold, QStringLiteral( "band1AttackThreshold" ) );
  KConfigCompilerSignallingItem  *itemBand2AttackThreshold;
  KConfigBaseEE::ItemDouble  *innerItemBand2AttackThreshold;
  innerItemBand2AttackThreshold = new KConfigBaseEE::ItemDouble( currentGroup(), QStringLiteral( "band2AttackThreshold" ), mBand2AttackThreshold, -12 );
  itemBand2AttackThreshold = new KConfigCompilerSignallingItem(innerItemBand2AttackThreshold, this, notifyFunction, signalBand2AttackThresholdChanged);
  innerItemBand2AttackThreshold->setMinValue(-60);
  innerItemBand2AttackThreshold->setMaxValue(0);
  itemBand2AttackThreshold->setWriteFlags(KConfigBase::Notify);
  itemBand2AttackThreshold->setGroup(cgMultibandCompressorinstanceIndex);
  addItem( itemBand2AttackThreshold, QStringLiteral( "band2AttackThreshold" ) );
  KConfigCompilerSignallingItem  *itemBand3AttackThreshold;
  KConfigBaseEE::ItemDouble  *innerItemBand3AttackThreshold;
  innerItemBand3AttackThreshold = new KConfigBaseEE::ItemDouble( currentGroup(), QStringLiteral( "band3AttackThreshold" ), mBand3AttackThreshold, -12 );
  itemBand3AttackThreshold = new KConfigCompilerSignallingItem(innerItemBand3AttackThreshold, this, notifyFunction, signalBand3AttackThresholdChanged);
  innerItemBand3AttackThreshold->setMinValue(-60);
  innerItemBand3AttackThreshold->setMaxValue(0);
  itemBand3AttackThreshold->setWriteFlags(KConfigBase::Notify);
  itemBand3AttackThreshold->setGroup(cgMultibandCompressorinstanceIndex);
  addItem( itemBand3AttackThreshold, QStringLiteral( "band3AttackThreshold" ) );
  KConfigCompilerSignallingItem  *itemBand4AttackThreshold;
  KConfigBaseEE::ItemDouble  *innerItemBand4AttackThreshold;
  innerItemBand4AttackThreshold = new KConfigBaseEE::ItemDouble( currentGroup(), QStringLiteral( "band4AttackThreshold" ), mBand4AttackThreshold, -12 );
  itemBand4AttackThreshold = new KConfigCompilerSignallingItem(innerItemBand4AttackThreshold, this, notifyFunction, signalBand4AttackThresholdChanged);
  innerItemBand4AttackThreshold->setMinValue(-60);
  innerItemBand4AttackThreshold->setMaxValue(0);
  itemBand4AttackThreshold->setWriteFlags(KConfigBase::Notify);
  itemBand4AttackThreshold->setGroup(cgMultibandCompressorinstanceIndex);
  addItem( itemBand4AttackThreshold, QStringLiteral( "band4AttackThreshold" ) );
  KConfigCompilerSignallingItem  *itemBand5AttackThreshold;
  KConfigBaseEE::ItemDouble  *innerItemBand5AttackThreshold;
  innerItemBand5AttackThreshold = new KConfigBaseEE::ItemDouble( currentGroup(), QStringLiteral( "band5AttackThreshold" ), mBand5AttackThreshold, -12 );
  itemBand5AttackThreshold = new KConfigCompilerSignallingItem(innerItemBand5AttackThreshold, this, notifyFunction, signalBand5AttackThresholdChanged);
  innerItemBand5AttackThreshold->setMinValue(-60);
  innerItemBand5AttackThreshold->setMaxValue(0);
  itemBand5AttackThreshold->setWriteFlags(KConfigBase::Notify);
  itemBand5AttackThreshold->setGroup(cgMultibandCompressorinstanceIndex);
  addItem( itemBand5AttackThreshold, QStringLiteral( "band5AttackThreshold" ) );
  KConfigCompilerSignallingItem  *itemBand6AttackThreshold;
  KConfigBaseEE::ItemDouble  *innerItemBand6AttackThreshold;
  innerItemBand6AttackThreshold = new KConfigBaseEE::ItemDouble( currentGroup(), QStringLiteral( "band6AttackThreshold" ), mBand6AttackThreshold, -12 );
  itemBand6AttackThreshold = new KConfigCompilerSignallingItem(innerItemBand6AttackThreshold, this, notifyFunction, signalBand6AttackThresholdChanged);
  innerItemBand6AttackThreshold->setMinValue(-60);
  innerItemBand6AttackThreshold->setMaxValue(0);
  itemBand6AttackThreshold->setWriteFlags(KConfigBase::Notify);
  itemBand6AttackThreshold->setGroup(cgMultibandCompressorinstanceIndex);
  addItem( itemBand6AttackThreshold, QStringLiteral( "band6AttackThreshold" ) );
  KConfigCompilerSignallingItem  *itemBand7AttackThreshold;
  KConfigBaseEE::ItemDouble  *innerItemBand7AttackThreshold;
  innerItemBand7AttackThreshold = new KConfigBaseEE::ItemDouble( currentGroup(), QStringLiteral( "band7AttackThreshold" ), mBand7AttackThreshold, -12 );
  itemBand7AttackThreshold = new KConfigCompilerSignallingItem(innerItemBand7AttackThreshold, this, notifyFunction, signalBand7AttackThresholdChanged);
  innerItemBand7AttackThreshold->setMinValue(-60);
  innerItemBand7AttackThreshold->setMaxValue(0);
  itemBand7AttackThreshold->setWriteFlags(KConfigBase::Notify);
  itemBand7AttackThreshold->setGroup(cgMultibandCompressorinstanceIndex);
  addItem( itemBand7AttackThreshold, QStringLiteral( "band7AttackThreshold" ) );
  KConfigCompilerSignallingItem  *itemBand0AttackTime;
  KConfigBaseEE::ItemDouble  *innerItemBand0AttackTime;
  innerItemBand0AttackTime = new KConfigBaseEE::ItemDouble( currentGroup(), QStringLiteral( "band0AttackTime" ), mBand0AttackTime, 20 );
  itemBand0AttackTime = new KConfigCompilerSignallingItem(innerItemBand0AttackTime, this, notifyFunction, signalBand0AttackTimeChanged);
  innerItemBand0AttackTime->setMinValue(0);
  innerItemBand0AttackTime->setMaxValue(2000);
  itemBand0AttackTime->setWriteFlags(KConfigBase::Notify);
  itemBand0AttackTime->setGroup(cgMultibandCompressorinstanceIndex);
  addItem( itemBand0AttackTime, QStringLiteral( "band0AttackTime" ) );
  KConfigCompilerSignallingItem  *itemBand1AttackTime;
  KConfigBaseEE::ItemDouble  *innerItemBand1AttackTime;
  innerItemBand1AttackTime = new KConfigBaseEE::ItemDouble( currentGroup(), QStringLiteral( "band1AttackTime" ), mBand1AttackTime, 20 );
  itemBand1AttackTime = new KConfigCompilerSignallingItem(innerItemBand1AttackTime, this, notifyFunction, signalBand1AttackTimeChanged);
  innerItemBand1AttackTime->setMinValue(0);
  innerItemBand1AttackTime->setMaxValue(2000);
  itemBand1AttackTime->setWriteFlags(KConfigBase::Notify);
  itemBand1AttackTime->setGroup(cgMultibandCompressorinstanceIndex);
  addItem( itemBand1AttackTime, QStringLiteral( "band1AttackTime" ) );
  KConfigCompilerSignallingItem  *itemBand2AttackTime;
  KConfigBaseEE::ItemDouble  *innerItemBand2AttackTime;
  innerItemBand2AttackTime = new KConfigBaseEE::ItemDouble( currentGroup(), QStringLiteral( "band2AttackTime" ), mBand2AttackTime, 20 );
  itemBand2AttackTime = new KConfigCompilerSignallingItem(innerItemBand2AttackTime, this, notifyFunction, signalBand2AttackTimeChanged);
  innerItemBand2AttackTime->setMinValue(0);
  innerItemBand2AttackTime->setMaxValue(2000);
  itemBand2AttackTime->setWriteFlags(KConfigBase::Notify);
  itemBand2AttackTime->setGroup(cgMultibandCompressorinstanceIndex);
  addItem( itemBand2AttackTime, QStringLiteral( "band2AttackTime" ) );
  KConfigCompilerSignallingItem  *itemBand3AttackTime;
  KConfigBaseEE::ItemDouble  *innerItemBand3AttackTime;
  innerItemBand3AttackTime = new KConfigBaseEE::ItemDouble( currentGroup(), QStringLiteral( "band3AttackTime" ), mBand3AttackTime, 20 );
  itemBand3AttackTime = new KConfigCompilerSignallingItem(innerItemBand3AttackTime, this, notifyFunction, signalBand3AttackTimeChanged);
  innerItemBand3AttackTime->setMinValue(0);
  innerItemBand3AttackTime->setMaxValue(2000);
  itemBand3AttackTime->setWriteFlags(KConfigBase::Notify);
  itemBand3AttackTime->setGroup(cgMultibandCompressorinstanceIndex);
  addItem( itemBand3AttackTime, QStringLiteral( "band3AttackTime" ) );
  KConfigCompilerSignallingItem  *itemBand4AttackTime;
  KConfigBaseEE::ItemDouble  *innerItemBand4AttackTime;
  innerItemBand4AttackTime = new KConfigBaseEE::ItemDouble( currentGroup(), QStringLiteral( "band4AttackTime" ), mBand4AttackTime, 20 );
  itemBand4AttackTime = new KConfigCompilerSignallingItem(innerItemBand4AttackTime, this, notifyFunction, signalBand4AttackTimeChanged);
  innerItemBand4AttackTime->setMinValue(0);
  innerItemBand4AttackTime->setMaxValue(2000);
  itemBand4AttackTime->setWriteFlags(KConfigBase::Notify);
  itemBand4AttackTime->setGroup(cgMultibandCompressorinstanceIndex);
  addItem( itemBand4AttackTime, QStringLiteral( "band4AttackTime" ) );
  KConfigCompilerSignallingItem  *itemBand5AttackTime;
  KConfigBaseEE::ItemDouble  *innerItemBand5AttackTime;
  innerItemBand5AttackTime = new KConfigBaseEE::ItemDouble( currentGroup(), QStringLiteral( "band5AttackTime" ), mBand5AttackTime, 20 );
  itemBand5AttackTime = new KConfigCompilerSignallingItem(innerItemBand5AttackTime, this, notifyFunction, signalBand5AttackTimeChanged);
  innerItemBand5AttackTime->setMinValue(0);
  innerItemBand5AttackTime->setMaxValue(2000);
  itemBand5AttackTime->setWriteFlags(KConfigBase::Notify);
  itemBand5AttackTime->setGroup(cgMultibandCompressorinstanceIndex);
  addItem( itemBand5AttackTime, QStringLiteral( "band5AttackTime" ) );
  KConfigCompilerSignallingItem  *itemBand6AttackTime;
  KConfigBaseEE::ItemDouble  *innerItemBand6AttackTime;
  innerItemBand6AttackTime = new KConfigBaseEE::ItemDouble( currentGroup(), QStringLiteral( "band6AttackTime" ), mBand6AttackTime, 20 );
  itemBand6AttackTime = new KConfigCompilerSignallingItem(innerItemBand6AttackTime, this, notifyFunction, signalBand6AttackTimeChanged);
  innerItemBand6AttackTime->setMinValue(0);
  innerItemBand6AttackTime->setMaxValue(2000);
  itemBand6AttackTime->setWriteFlags(KConfigBase::Notify);
  itemBand6AttackTime->setGroup(cgMultibandCompressorinstanceIndex);
  addItem( itemBand6AttackTime, QStringLiteral( "band6AttackTime" ) );
  KConfigCompilerSignallingItem  *itemBand7AttackTime;
  KConfigBaseEE::ItemDouble  *innerItemBand7AttackTime;
  innerItemBand7AttackTime = new KConfigBaseEE::ItemDouble( currentGroup(), QStringLiteral( "band7AttackTime" ), mBand7AttackTime, 20 );
  itemBand7AttackTime = new KConfigCompilerSignallingItem(innerItemBand7AttackTime, this, notifyFunction, signalBand7AttackTimeChanged);
  innerItemBand7AttackTime->setMinValue(0);
  innerItemBand7AttackTime->setMaxValue(2000);
  itemBand7AttackTime->setWriteFlags(KConfigBase::Notify);
  itemBand7AttackTime->setGroup(cgMultibandCompressorinstanceIndex);
  addItem( itemBand7AttackTime, QStringLiteral( "band7AttackTime" ) );
  KConfigCompilerSignallingItem  *itemBand0ReleaseThreshold;
  KConfigBaseEE::ItemDouble  *innerItemBand0ReleaseThreshold;
  innerItemBand0ReleaseThreshold = new KConfigBaseEE::ItemDouble( currentGroup(), QStringLiteral( "band0ReleaseThreshold" ), mBand0ReleaseThreshold, -80.01 );
  itemBand0ReleaseThreshold = new KConfigCompilerSignallingItem(innerItemBand0ReleaseThreshold, this, notifyFunction, signalBand0ReleaseThresholdChanged);
  innerItemBand0ReleaseThreshold->setMinValue(-80.01);
  innerItemBand0ReleaseThreshold->setMaxValue(36);
  itemBand0ReleaseThreshold->setWriteFlags(KConfigBase::Notify);
  itemBand0ReleaseThreshold->setGroup(cgMultibandCompressorinstanceIndex);
  addItem( itemBand0ReleaseThreshold, QStringLiteral( "band0ReleaseThreshold" ) );
  KConfigCompilerSignallingItem  *itemBand1ReleaseThreshold;
  KConfigBaseEE::ItemDouble  *innerItemBand1ReleaseThreshold;
  innerItemBand1ReleaseThreshold = new KConfigBaseEE::ItemDouble( currentGroup(), QStringLiteral( "band1ReleaseThreshold" ), mBand1ReleaseThreshold, -80.01 );
  itemBand1ReleaseThreshold = new KConfigCompilerSignallingItem(innerItemBand1ReleaseThreshold, this, notifyFunction, signalBand1ReleaseThresholdChanged);
  innerItemBand1ReleaseThreshold->setMinValue(-80.01);
  innerItemBand1ReleaseThreshold->setMaxValue(36);
  itemBand1ReleaseThreshold->setWriteFlags(KConfigBase::Notify);
  itemBand1ReleaseThreshold->setGroup(cgMultibandCompressorinstanceIndex);
  addItem( itemBand1ReleaseThreshold, QStringLiteral( "band1ReleaseThreshold" ) );
  KConfigCompilerSignallingItem  *itemBand2ReleaseThreshold;
  KConfigBaseEE::ItemDouble  *innerItemBand2ReleaseThreshold;
  innerItemBand2ReleaseThreshold = new KConfigBaseEE::ItemDouble( currentGroup(), QStringLiteral( "band2ReleaseThreshold" ), mBand2ReleaseThreshold, -80.01 );
  itemBand2ReleaseThreshold = new KConfigCompilerSignallingItem(innerItemBand2ReleaseThreshold, this, notifyFunction, signalBand2ReleaseThresholdChanged);
  innerItemBand2ReleaseThreshold->setMinValue(-80.01);
  innerItemBand2ReleaseThreshold->setMaxValue(36);
  itemBand2ReleaseThreshold->setWriteFlags(KConfigBase::Notify);
  itemBand2ReleaseThreshold->setGroup(cgMultibandCompressorinstanceIndex);
  addItem( itemBand2ReleaseThreshold, QStringLiteral( "band2ReleaseThreshold" ) );
  KConfigCompilerSignallingItem  *itemBand3ReleaseThreshold;
  KConfigBaseEE::ItemDouble  *innerItemBand3ReleaseThreshold;
  innerItemBand3ReleaseThreshold = new KConfigBaseEE::ItemDouble( currentGroup(), QStringLiteral( "band3ReleaseThreshold" ), mBand3ReleaseThreshold, -80.01 );
  itemBand3ReleaseThreshold = new KConfigCompilerSignallingItem(innerItemBand3ReleaseThreshold, this, notifyFunction, signalBand3ReleaseThresholdChanged);
  innerItemBand3ReleaseThreshold->setMinValue(-80.01);
  innerItemBand3ReleaseThreshold->setMaxValue(36);
  itemBand3ReleaseThreshold->setWriteFlags(KConfigBase::Notify);
  itemBand3ReleaseThreshold->setGroup(cgMultibandCompressorinstanceIndex);
  addItem( itemBand3ReleaseThreshold, QStringLiteral( "band3ReleaseThreshold" ) );
  KConfigCompilerSignallingItem  *itemBand4ReleaseThreshold;
  KConfigBaseEE::ItemDouble  *innerItemBand4ReleaseThreshold;
  innerItemBand4ReleaseThreshold = new KConfigBaseEE::ItemDouble( currentGroup(), QStringLiteral( "band4ReleaseThreshold" ), mBand4ReleaseThreshold, -80.01 );
  itemBand4ReleaseThreshold = new KConfigCompilerSignallingItem(innerItemBand4ReleaseThreshold, this, notifyFunction, signalBand4ReleaseThresholdChanged);
  innerItemBand4ReleaseThreshold->setMinValue(-80.01);
  innerItemBand4ReleaseThreshold->setMaxValue(36);
  itemBand4ReleaseThreshold->setWriteFlags(KConfigBase::Notify);
  itemBand4ReleaseThreshold->setGroup(cgMultibandCompressorinstanceIndex);
  addItem( itemBand4ReleaseThreshold, QStringLiteral( "band4ReleaseThreshold" ) );
  KConfigCompilerSignallingItem  *itemBand5ReleaseThreshold;
  KConfigBaseEE::ItemDouble  *innerItemBand5ReleaseThreshold;
  innerItemBand5ReleaseThreshold = new KConfigBaseEE::ItemDouble( currentGroup(), QStringLiteral( "band5ReleaseThreshold" ), mBand5ReleaseThreshold, -80.01 );
  itemBand5ReleaseThreshold = new KConfigCompilerSignallingItem(innerItemBand5ReleaseThreshold, this, notifyFunction, signalBand5ReleaseThresholdChanged);
  innerItemBand5ReleaseThreshold->setMinValue(-80.01);
  innerItemBand5ReleaseThreshold->setMaxValue(36);
  itemBand5ReleaseThreshold->setWriteFlags(KConfigBase::Notify);
  itemBand5ReleaseThreshold->setGroup(cgMultibandCompressorinstanceIndex);
  addItem( itemBand5ReleaseThreshold, QStringLiteral( "band5ReleaseThreshold" ) );
  KConfigCompilerSignallingItem  *itemBand6ReleaseThreshold;
  KConfigBaseEE::ItemDouble  *innerItemBand6ReleaseThreshold;
  innerItemBand6ReleaseThreshold = new KConfigBaseEE::ItemDouble( currentGroup(), QStringLiteral( "band6ReleaseThreshold" ), mBand6ReleaseThreshold, -80.01 );
  itemBand6ReleaseThreshold = new KConfigCompilerSignallingItem(innerItemBand6ReleaseThreshold, this, notifyFunction, signalBand6ReleaseThresholdChanged);
  innerItemBand6ReleaseThreshold->setMinValue(-80.01);
  innerItemBand6ReleaseThreshold->setMaxValue(36);
  itemBand6ReleaseThreshold->setWriteFlags(KConfigBase::Notify);
  itemBand6ReleaseThreshold->setGroup(cgMultibandCompressorinstanceIndex);
  addItem( itemBand6ReleaseThreshold, QStringLiteral( "band6ReleaseThreshold" ) );
  KConfigCompilerSignallingItem  *itemBand7ReleaseThreshold;
  KConfigBaseEE::ItemDouble  *innerItemBand7ReleaseThreshold;
  innerItemBand7ReleaseThreshold = new KConfigBaseEE::ItemDouble( currentGroup(), QStringLiteral( "band7ReleaseThreshold" ), mBand7ReleaseThreshold, -80.01 );
  itemBand7ReleaseThreshold = new KConfigCompilerSignallingItem(innerItemBand7ReleaseThreshold, this, notifyFunction, signalBand7ReleaseThresholdChanged);
  innerItemBand7ReleaseThreshold->setMinValue(-80.01);
  innerItemBand7ReleaseThreshold->setMaxValue(36);
  itemBand7ReleaseThreshold->setWriteFlags(KConfigBase::Notify);
  itemBand7ReleaseThreshold->setGroup(cgMultibandCompressorinstanceIndex);
  addItem( itemBand7ReleaseThreshold, QStringLiteral( "band7ReleaseThreshold" ) );
  KConfigCompilerSignallingItem  *itemBand0ReleaseTime;
  KConfigBaseEE::ItemDouble  *innerItemBand0ReleaseTime;
  innerItemBand0ReleaseTime = new KConfigBaseEE::ItemDouble( currentGroup(), QStringLiteral( "band0ReleaseTime" ), mBand0ReleaseTime, 100 );
  itemBand0ReleaseTime = new KConfigCompilerSignallingItem(innerItemBand0ReleaseTime, this, notifyFunction, signalBand0ReleaseTimeChanged);
  innerItemBand0ReleaseTime->setMinValue(0);
  innerItemBand0ReleaseTime->setMaxValue(5000);
  itemBand0ReleaseTime->setWriteFlags(KConfigBase::Notify);
  itemBand0ReleaseTime->setGroup(cgMultibandCompressorinstanceIndex);
  addItem( itemBand0ReleaseTime, QStringLiteral( "band0ReleaseTime" ) );
  KConfigCompilerSignallingItem  *itemBand1ReleaseTime;
  KConfigBaseEE::ItemDouble  *innerItemBand1ReleaseTime;
  innerItemBand1ReleaseTime = new KConfigBaseEE::ItemDouble( currentGroup(), QStringLiteral( "band1ReleaseTime" ), mBand1ReleaseTime, 100 );
  itemBand1ReleaseTime = new KConfigCompilerSignallingItem(innerItemBand1ReleaseTime, this, notifyFunction, signalBand1ReleaseTimeChanged);
  innerItemBand1ReleaseTime->setMinValue(0);
  innerItemBand1ReleaseTime->setMaxValue(5000);
  itemBand1ReleaseTime->setWriteFlags(KConfigBase::Notify);
  itemBand1ReleaseTime->setGroup(cgMultibandCompressorinstanceIndex);
  addItem( itemBand1ReleaseTime, QStringLiteral( "band1ReleaseTime" ) );
  KConfigCompilerSignallingItem  *itemBand2ReleaseTime;
  KConfigBaseEE::ItemDouble  *innerItemBand2ReleaseTime;
  innerItemBand2ReleaseTime = new KConfigBaseEE::ItemDouble( currentGroup(), QStringLiteral( "band2ReleaseTime" ), mBand2ReleaseTime, 100 );
  itemBand2ReleaseTime = new KConfigCompilerSignallingItem(innerItemBand2ReleaseTime, this, notifyFunction, signalBand2ReleaseTimeChanged);
  innerItemBand2ReleaseTime->setMinValue(0);
  innerItemBand2ReleaseTime->setMaxValue(5000);
  itemBand2ReleaseTime->setWriteFlags(KConfigBase::Notify);
  itemBand2ReleaseTime->setGroup(cgMultibandCompressorinstanceIndex);
  addItem( itemBand2ReleaseTime, QStringLiteral( "band2ReleaseTime" ) );
  KConfigCompilerSignallingItem  *itemBand3ReleaseTime;
  KConfigBaseEE::ItemDouble  *innerItemBand3ReleaseTime;
  innerItemBand3ReleaseTime = new KConfigBaseEE::ItemDouble( currentGroup(), QStringLiteral( "band3ReleaseTime" ), mBand3ReleaseTime, 100 );
  itemBand3ReleaseTime = new KConfigCompilerSignallingItem(innerItemBand3ReleaseTime, this, notifyFunction, signalBand3ReleaseTimeChanged);
  innerItemBand3ReleaseTime->setMinValue(0);
  innerItemBand3ReleaseTime->setMaxValue(5000);
  itemBand3ReleaseTime->setWriteFlags(KConfigBase::Notify);
  itemBand3ReleaseTime->setGroup(cgMultibandCompressorinstanceIndex);
  addItem( itemBand3ReleaseTime, QStringLiteral( "band3ReleaseTime" ) );
  KConfigCompilerSignallingItem  *itemBand4ReleaseTime;
  KConfigBaseEE::ItemDouble  *innerItemBand4ReleaseTime;
  innerItemBand4ReleaseTime = new KConfigBaseEE::ItemDouble( currentGroup(), QStringLiteral( "band4ReleaseTime" ), mBand4ReleaseTime, 100 );
  itemBand4ReleaseTime = new KConfigCompilerSignallingItem(innerItemBand4ReleaseTime, this, notifyFunction, signalBand4ReleaseTimeChanged);
  innerItemBand4ReleaseTime->setMinValue(0);
  innerItemBand4ReleaseTime->setMaxValue(5000);
  itemBand4ReleaseTime->setWriteFlags(KConfigBase::Notify);
  itemBand4ReleaseTime->setGroup(cgMultibandCompressorinstanceIndex);
  addItem( itemBand4ReleaseTime, QStringLiteral( "band4ReleaseTime" ) );
  KConfigCompilerSignallingItem  *itemBand5ReleaseTime;
  KConfigBaseEE::ItemDouble  *innerItemBand5ReleaseTime;
  innerItemBand5ReleaseTime = new KConfigBaseEE::ItemDouble( currentGroup(), QStringLiteral( "band5ReleaseTime" ), mBand5ReleaseTime, 100 );
  itemBand5ReleaseTime = new KConfigCompilerSignallingItem(innerItemBand5ReleaseTime, this, notifyFunction, signalBand5ReleaseTimeChanged);
  innerItemBand5ReleaseTime->setMinValue(0);
  innerItemBand5ReleaseTime->setMaxValue(5000);
  itemBand5ReleaseTime->setWriteFlags(KConfigBase::Notify);
  itemBand5ReleaseTime->setGroup(cgMultibandCompressorinstanceIndex);
  addItem( itemBand5ReleaseTime, QStringLiteral( "band5ReleaseTime" ) );
  KConfigCompilerSignallingItem  *itemBand6ReleaseTime;
  KConfigBaseEE::ItemDouble  *innerItemBand6ReleaseTime;
  innerItemBand6ReleaseTime = new KConfigBaseEE::ItemDouble( currentGroup(), QStringLiteral( "band6ReleaseTime" ), mBand6ReleaseTime, 100 );
  itemBand6ReleaseTime = new KConfigCompilerSignallingItem(innerItemBand6ReleaseTime, this, notifyFunction, signalBand6ReleaseTimeChanged);
  innerItemBand6ReleaseTime->setMinValue(0);
  innerItemBand6ReleaseTime->setMaxValue(5000);
  itemBand6ReleaseTime->setWriteFlags(KConfigBase::Notify);
  itemBand6ReleaseTime->setGroup(cgMultibandCompressorinstanceIndex);
  addItem( itemBand6ReleaseTime, QStringLiteral( "band6ReleaseTime" ) );
  KConfigCompilerSignallingItem  *itemBand7ReleaseTime;
  KConfigBaseEE::ItemDouble  *innerItemBand7ReleaseTime;
  innerItemBand7ReleaseTime = new KConfigBaseEE::ItemDouble( currentGroup(), QStringLiteral( "band7ReleaseTime" ), mBand7ReleaseTime, 100 );
  itemBand7ReleaseTime = new KConfigCompilerSignallingItem(innerItemBand7ReleaseTime, this, notifyFunction, signalBand7ReleaseTimeChanged);
  innerItemBand7ReleaseTime->setMinValue(0);
  innerItemBand7ReleaseTime->setMaxValue(5000);
  itemBand7ReleaseTime->setWriteFlags(KConfigBase::Notify);
  itemBand7ReleaseTime->setGroup(cgMultibandCompressorinstanceIndex);
  addItem( itemBand7ReleaseTime, QStringLiteral( "band7ReleaseTime" ) );
  KConfigCompilerSignallingItem  *itemBand0Ratio;
  KConfigBaseEE::ItemDouble  *innerItemBand0Ratio;
  innerItemBand0Ratio = new KConfigBaseEE::ItemDouble( currentGroup(), QStringLiteral( "band0Ratio" ), mBand0Ratio, 1 );
  itemBand0Ratio = new KConfigCompilerSignallingItem(innerItemBand0Ratio, this, notifyFunction, signalBand0RatioChanged);
  innerItemBand0Ratio->setMinValue(1);
  innerItemBand0Ratio->setMaxValue(100);
  itemBand0Ratio->setWriteFlags(KConfigBase::Notify);
  itemBand0Ratio->setGroup(cgMultibandCompressorinstanceIndex);
  addItem( itemBand0Ratio, QStringLiteral( "band0Ratio" ) );
  KConfigCompilerSignallingItem  *itemBand1Ratio;
  KConfigBaseEE::ItemDouble  *innerItemBand1Ratio;
  innerItemBand1Ratio = new KConfigBaseEE::ItemDouble( currentGroup(), QStringLiteral( "band1Ratio" ), mBand1Ratio, 1 );
  itemBand1Ratio = new KConfigCompilerSignallingItem(innerItemBand1Ratio, this, notifyFunction, signalBand1RatioChanged);
  innerItemBand1Ratio->setMinValue(1);
  innerItemBand1Ratio->setMaxValue(100);
  itemBand1Ratio->setWriteFlags(KConfigBase::Notify);
  itemBand1Ratio->setGroup(cgMultibandCompressorinstanceIndex);
  addItem( itemBand1Ratio, QStringLiteral( "band1Ratio" ) );
  KConfigCompilerSignallingItem  *itemBand2Ratio;
  KConfigBaseEE::ItemDouble  *innerItemBand2Ratio;
  innerItemBand2Ratio = new KConfigBaseEE::ItemDouble( currentGroup(), QStringLiteral( "band2Ratio" ), mBand2Ratio, 1 );
  itemBand2Ratio = new KConfigCompilerSignallingItem(innerItemBand2Ratio, this, notifyFunction, signalBand2RatioChanged);
  innerItemBand2Ratio->setMinValue(1);
  innerItemBand2Ratio->setMaxValue(100);
  itemBand2Ratio->setWriteFlags(KConfigBase::Notify);
  itemBand2Ratio->setGroup(cgMultibandCompressorinstanceIndex);
  addItem( itemBand2Ratio, QStringLiteral( "band2Ratio" ) );
  KConfigCompilerSignallingItem  *itemBand3Ratio;
  KConfigBaseEE::ItemDouble  *innerItemBand3Ratio;
  innerItemBand3Ratio = new KConfigBaseEE::ItemDouble( currentGroup(), QStringLiteral( "band3Ratio" ), mBand3Ratio, 1 );
  itemBand3Ratio = new KConfigCompilerSignallingItem(innerItemBand3Ratio, this, notifyFunction, signalBand3RatioChanged);
  innerItemBand3Ratio->setMinValue(1);
  innerItemBand3Ratio->setMaxValue(100);
  itemBand3Ratio->setWriteFlags(KConfigBase::Notify);
  itemBand3Ratio->setGroup(cgMultibandCompressorinstanceIndex);
  addItem( itemBand3Ratio, QStringLiteral( "band3Ratio" ) );
  KConfigCompilerSignallingItem  *itemBand4Ratio;
  KConfigBaseEE::ItemDouble  *innerItemBand4Ratio;
  innerItemBand4Ratio = new KConfigBaseEE::ItemDouble( currentGroup(), QStringLiteral( "band4Ratio" ), mBand4Ratio, 1 );
  itemBand4Ratio = new KConfigCompilerSignallingItem(innerItemBand4Ratio, this, notifyFunction, signalBand4RatioChanged);
  innerItemBand4Ratio->setMinValue(1);
  innerItemBand4Ratio->setMaxValue(100);
  itemBand4Ratio->setWriteFlags(KConfigBase::Notify);
  itemBand4Ratio->setGroup(cgMultibandCompressorinstanceIndex);
  addItem( itemBand4Ratio, QStringLiteral( "band4Ratio" ) );
  KConfigCompilerSignallingItem  *itemBand5Ratio;
  KConfigBaseEE::ItemDouble  *innerItemBand5Ratio;
  innerItemBand5Ratio = new KConfigBaseEE::ItemDouble( currentGroup(), QStringLiteral( "band5Ratio" ), mBand5Ratio, 1 );
  itemBand5Ratio = new KConfigCompilerSignallingItem(innerItemBand5Ratio, this, notifyFunction, signalBand5RatioChanged);
  innerItemBand5Ratio->setMinValue(1);
  innerItemBand5Ratio->setMaxValue(100);
  itemBand5Ratio->setWriteFlags(KConfigBase::Notify);
  itemBand5Ratio->setGroup(cgMultibandCompressorinstanceIndex);
  addItem( itemBand5Ratio, QStringLiteral( "band5Ratio" ) );
  KConfigCompilerSignallingItem  *itemBand6Ratio;
  KConfigBaseEE::ItemDouble  *innerItemBand6Ratio;
  innerItemBand6Ratio = new KConfigBaseEE::ItemDouble( currentGroup(), QStringLiteral( "band6Ratio" ), mBand6Ratio, 1 );
  itemBand6Ratio = new KConfigCompilerSignallingItem(innerItemBand6Ratio, this, notifyFunction, signalBand6RatioChanged);
  innerItemBand6Ratio->setMinValue(1);
  innerItemBand6Ratio->setMaxValue(100);
  itemBand6Ratio->setWriteFlags(KConfigBase::Notify);
  itemBand6Ratio->setGroup(cgMultibandCompressorinstanceIndex);
  addItem( itemBand6Ratio, QStringLiteral( "band6Ratio" ) );
  KConfigCompilerSignallingItem  *itemBand7Ratio;
  KConfigBaseEE::ItemDouble  *innerItemBand7Ratio;
  innerItemBand7Ratio = new KConfigBaseEE::ItemDouble( currentGroup(), QStringLiteral( "band7Ratio" ), mBand7Ratio, 1 );
  itemBand7Ratio = new KConfigCompilerSignallingItem(innerItemBand7Ratio, this, notifyFunction, signalBand7RatioChanged);
  innerItemBand7Ratio->setMinValue(1);
  innerItemBand7Ratio->setMaxValue(100);
  itemBand7Ratio->setWriteFlags(KConfigBase::Notify);
  itemBand7Ratio->setGroup(cgMultibandCompressorinstanceIndex);
  addItem( itemBand7Ratio, QStringLiteral( "band7Ratio" ) );
  KConfigCompilerSignallingItem  *itemBand0Knee;
  KConfigBaseEE::ItemDouble  *innerItemBand0Knee;
  innerItemBand0Knee = new KConfigBaseEE::ItemDouble( currentGroup(), QStringLiteral( "band0Knee" ), mBand0Knee, -6 );
  itemBand0Knee = new KConfigCompilerSignallingItem(innerItemBand0Knee, this, notifyFunction, signalBand0KneeChanged);
  innerItemBand0Knee->setMinValue(-24);
  innerItemBand0Knee->setMaxValue(0);
  itemBand0Knee->setWriteFlags(KConfigBase::Notify);
  itemBand0Knee->setGroup(cgMultibandCompressorinstanceIndex);
  addItem( itemBand0Knee, QStringLiteral( "band0Knee" ) );
  KConfigCompilerSignallingItem  *itemBand1Knee;
  KConfigBaseEE::ItemDouble  *innerItemBand1Knee;
  innerItemBand1Knee = new KConfigBaseEE::ItemDouble( currentGroup(), QStringLiteral( "band1Knee" ), mBand1Knee, -6 );
  itemBand1Knee = new KConfigCompilerSignallingItem(innerItemBand1Knee, this, notifyFunction, signalBand1KneeChanged);
  innerItemBand1Knee->setMinValue(-24);
  innerItemBand1Knee->setMaxValue(0);
  itemBand1Knee->setWriteFlags(KConfigBase::Notify);
  itemBand1Knee->setGroup(cgMultibandCompressorinstanceIndex);
  addItem( itemBand1Knee, QStringLiteral( "band1Knee" ) );
  KConfigCompilerSignallingItem  *itemBand2Knee;
  KConfigBaseEE::ItemDouble  *innerItemBand2Knee;
  innerItemBand2Knee = new KConfigBaseEE::ItemDouble( currentGroup(), QStringLiteral( "band2Knee" ), mBand2Knee, -6 );
  itemBand2Knee = new KConfigCompilerSignallingItem(innerItemBand2Knee, this, notifyFunction, signalBand2KneeChanged);
  innerItemBand2Knee->setMinValue(-24);
  innerItemBand2Knee->setMaxValue(0);
  itemBand2Knee->setWriteFlags(KConfigBase::Notify);
  itemBand2Knee->setGroup(cgMultibandCompressorinstanceIndex);
  addItem( itemBand2Knee, QStringLiteral( "band2Knee" ) );
  KConfigCompilerSignallingItem  *itemBand3Knee;
  KConfigBaseEE::ItemDouble  *innerItemBand3Knee;
  innerItemBand3Knee = new KConfigBaseEE::ItemDouble( currentGroup(), QStringLiteral( "band3Knee" ), mBand3Knee, -6 );
  itemBand3Knee = new KConfigCompilerSignallingItem(innerItemBand3Knee, this, notifyFunction, signalBand3KneeChanged);
  innerItemBand3Knee->setMinValue(-24);
  innerItemBand3Knee->setMaxValue(0);
  itemBand3Knee->setWriteFlags(KConfigBase::Notify);
  itemBand3Knee->setGroup(cgMultibandCompressorinstanceIndex);
  addItem( itemBand3Knee, QStringLiteral( "band3Knee" ) );
  KConfigCompilerSignallingItem  *itemBand4Knee;
  KConfigBaseEE::ItemDouble  *innerItemBand4Knee;
  innerItemBand4Knee = new KConfigBaseEE::ItemDouble( currentGroup(), QStringLiteral( "band4Knee" ), mBand4Knee, -6 );
  itemBand4Knee = new KConfigCompilerSignallingItem(innerItemBand4Knee, this, notifyFunction, signalBand4KneeChanged);
  innerItemBand4Knee->setMinValue(-24);
  innerItemBand4Knee->setMaxValue(0);
  itemBand4Knee->setWriteFlags(KConfigBase::Notify);
  itemBand4Knee->setGroup(cgMultibandCompressorinstanceIndex);
  addItem( itemBand4Knee, QStringLiteral( "band4Knee" ) );
  KConfigCompilerSignallingItem  *itemBand5Knee;
  KConfigBaseEE::ItemDouble  *innerItemBand5Knee;
  innerItemBand5Knee = new KConfigBaseEE::ItemDouble( currentGroup(), QStringLiteral( "band5Knee" ), mBand5Knee, -6 );
  itemBand5Knee = new KConfigCompilerSignallingItem(innerItemBand5Knee, this, notifyFunction, signalBand5KneeChanged);
  innerItemBand5Knee->setMinValue(-24);
  innerItemBand5Knee->setMaxValue(0);
  itemBand5Knee->setWriteFlags(KConfigBase::Notify);
  itemBand5Knee->setGroup(cgMultibandCompressorinstanceIndex);
  addItem( itemBand5Knee, QStringLiteral( "band5Knee" ) );
  KConfigCompilerSignallingItem  *itemBand6Knee;
  KConfigBaseEE::ItemDouble  *innerItemBand6Knee;
  innerItemBand6Knee = new KConfigBaseEE::ItemDouble( currentGroup(), QStringLiteral( "band6Knee" ), mBand6Knee, -6 );
  itemBand6Knee = new KConfigCompilerSignallingItem(innerItemBand6Knee, this, notifyFunction, signalBand6KneeChanged);
  innerItemBand6Knee->setMinValue(-24);
  innerItemBand6Knee->setMaxValue(0);
  itemBand6Knee->setWriteFlags(KConfigBase::Notify);
  itemBand6Knee->setGroup(cgMultibandCompressorinstanceIndex);
  addItem( itemBand6Knee, QStringLiteral( "band6Knee" ) );
  KConfigCompilerSignallingItem  *itemBand7Knee;
  KConfigBaseEE::ItemDouble  *innerItemBand7Knee;
  innerItemBand7Knee = new KConfigBaseEE::ItemDouble( currentGroup(), QStringLiteral( "band7Knee" ), mBand7Knee, -6 );
  itemBand7Knee = new KConfigCompilerSignallingItem(innerItemBand7Knee, this, notifyFunction, signalBand7KneeChanged);
  innerItemBand7Knee->setMinValue(-24);
  innerItemBand7Knee->setMaxValue(0);
  itemBand7Knee->setWriteFlags(KConfigBase::Notify);
  itemBand7Knee->setGroup(cgMultibandCompressorinstanceIndex);
  addItem( itemBand7Knee, QStringLiteral( "band7Knee" ) );
  KConfigCompilerSignallingItem  *itemBand0BoostThreshold;
  KConfigBaseEE::ItemDouble  *innerItemBand0BoostThreshold;
  innerItemBand0BoostThreshold = new KConfigBaseEE::ItemDouble( currentGroup(), QStringLiteral( "band0BoostThreshold" ), mBand0BoostThreshold, -72 );
  itemBand0BoostThreshold = new KConfigCompilerSignallingItem(innerItemBand0BoostThreshold, this, notifyFunction, signalBand0BoostThresholdChanged);
  innerItemBand0BoostThreshold->setMinValue(-120);
  innerItemBand0BoostThreshold->setMaxValue(-60);
  itemBand0BoostThreshold->setWriteFlags(KConfigBase::Notify);
  itemBand0BoostThreshold->setGroup(cgMultibandCompressorinstanceIndex);
  addItem( itemBand0BoostThreshold, QStringLiteral( "band0BoostThreshold" ) );
  KConfigCompilerSignallingItem  *itemBand1BoostThreshold;
  KConfigBaseEE::ItemDouble  *innerItemBand1BoostThreshold;
  innerItemBand1BoostThreshold = new KConfigBaseEE::ItemDouble( currentGroup(), QStringLiteral( "band1BoostThreshold" ), mBand1BoostThreshold, -72 );
  itemBand1BoostThreshold = new KConfigCompilerSignallingItem(innerItemBand1BoostThreshold, this, notifyFunction, signalBand1BoostThresholdChanged);
  innerItemBand1BoostThreshold->setMinValue(-120);
  innerItemBand1BoostThreshold->setMaxValue(-60);
  itemBand1BoostThreshold->setWriteFlags(KConfigBase::Notify);
  itemBand1BoostThreshold->setGroup(cgMultibandCompressorinstanceIndex);
  addItem( itemBand1BoostThreshold, QStringLiteral( "band1BoostThreshold" ) );
  KConfigCompilerSignallingItem  *itemBand2BoostThreshold;
  KConfigBaseEE::ItemDouble  *innerItemBand2BoostThreshold;
  innerItemBand2BoostThreshold = new KConfigBaseEE::ItemDouble( currentGroup(), QStringLiteral( "band2BoostThreshold" ), mBand2BoostThreshold, -72 );
  itemBand2BoostThreshold = new KConfigCompilerSignallingItem(innerItemBand2BoostThreshold, this, notifyFunction, signalBand2BoostThresholdChanged);
  innerItemBand2BoostThreshold->setMinValue(-120);
  innerItemBand2BoostThreshold->setMaxValue(-60);
  itemBand2BoostThreshold->setWriteFlags(KConfigBase::Notify);
  itemBand2BoostThreshold->setGroup(cgMultibandCompressorinstanceIndex);
  addItem( itemBand2BoostThreshold, QStringLiteral( "band2BoostThreshold" ) );
  KConfigCompilerSignallingItem  *itemBand3BoostThreshold;
  KConfigBaseEE::ItemDouble  *innerItemBand3BoostThreshold;
  innerItemBand3BoostThreshold = new KConfigBaseEE::ItemDouble( currentGroup(), QStringLiteral( "band3BoostThreshold" ), mBand3BoostThreshold, -72 );
  itemBand3BoostThreshold = new KConfigCompilerSignallingItem(innerItemBand3BoostThreshold, this, notifyFunction, signalBand3BoostThresholdChanged);
  innerItemBand3BoostThreshold->setMinValue(-120);
  innerItemBand3BoostThreshold->setMaxValue(-60);
  itemBand3BoostThreshold->setWriteFlags(KConfigBase::Notify);
  itemBand3BoostThreshold->setGroup(cgMultibandCompressorinstanceIndex);
  addItem( itemBand3BoostThreshold, QStringLiteral( "band3BoostThreshold" ) );
  KConfigCompilerSignallingItem  *itemBand4BoostThreshold;
  KConfigBaseEE::ItemDouble  *innerItemBand4BoostThreshold;
  innerItemBand4BoostThreshold = new KConfigBaseEE::ItemDouble( currentGroup(), QStringLiteral( "band4BoostThreshold" ), mBand4BoostThreshold, -72 );
  itemBand4BoostThreshold = new KConfigCompilerSignallingItem(innerItemBand4BoostThreshold, this, notifyFunction, signalBand4BoostThresholdChanged);
  innerItemBand4BoostThreshold->setMinValue(-120);
  innerItemBand4BoostThreshold->setMaxValue(-60);
  itemBand4BoostThreshold->setWriteFlags(KConfigBase::Notify);
  itemBand4BoostThreshold->setGroup(cgMultibandCompressorinstanceIndex);
  addItem( itemBand4BoostThreshold, QStringLiteral( "band4BoostThreshold" ) );
  KConfigCompilerSignallingItem  *itemBand5BoostThreshold;
  KConfigBaseEE::ItemDouble  *innerItemBand5BoostThreshold;
  innerItemBand5BoostThreshold = new KConfigBaseEE::ItemDouble( currentGroup(), QStringLiteral( "band5BoostThreshold" ), mBand5BoostThreshold, -72 );
  itemBand5BoostThreshold = new KConfigCompilerSignallingItem(innerItemBand5BoostThreshold, this, notifyFunction, signalBand5BoostThresholdChanged);
  innerItemBand5BoostThreshold->setMinValue(-120);
  innerItemBand5BoostThreshold->setMaxValue(-60);
  itemBand5BoostThreshold->setWriteFlags(KConfigBase::Notify);
  itemBand5BoostThreshold->setGroup(cgMultibandCompressorinstanceIndex);
  addItem( itemBand5BoostThreshold, QStringLiteral( "band5BoostThreshold" ) );
  KConfigCompilerSignallingItem  *itemBand6BoostThreshold;
  KConfigBaseEE::ItemDouble  *innerItemBand6BoostThreshold;
  innerItemBand6BoostThreshold = new KConfigBaseEE::ItemDouble( currentGroup(), QStringLiteral( "band6BoostThreshold" ), mBand6BoostThreshold, -72 );
  itemBand6BoostThreshold = new KConfigCompilerSignallingItem(innerItemBand6BoostThreshold, this, notifyFunction, signalBand6BoostThresholdChanged);
  innerItemBand6BoostThreshold->setMinValue(-120);
  innerItemBand6BoostThreshold->setMaxValue(-60);
  itemBand6BoostThreshold->setWriteFlags(KConfigBase::Notify);
  itemBand6BoostThreshold->setGroup(cgMultibandCompressorinstanceIndex);
  addItem( itemBand6BoostThreshold, QStringLiteral( "band6BoostThreshold" ) );
  KConfigCompilerSignallingItem  *itemBand7BoostThreshold;
  KConfigBaseEE::ItemDouble  *innerItemBand7BoostThreshold;
  innerItemBand7BoostThreshold = new KConfigBaseEE::ItemDouble( currentGroup(), QStringLiteral( "band7BoostThreshold" ), mBand7BoostThreshold, -72 );
  itemBand7BoostThreshold = new KConfigCompilerSignallingItem(innerItemBand7BoostThreshold, this, notifyFunction, signalBand7BoostThresholdChanged);
  innerItemBand7BoostThreshold->setMinValue(-120);
  innerItemBand7BoostThreshold->setMaxValue(-60);
  itemBand7BoostThreshold->setWriteFlags(KConfigBase::Notify);
  itemBand7BoostThreshold->setGroup(cgMultibandCompressorinstanceIndex);
  addItem( itemBand7BoostThreshold, QStringLiteral( "band7BoostThreshold" ) );
  KConfigCompilerSignallingItem  *itemBand0BoostAmount;
  KConfigBaseEE::ItemDouble  *innerItemBand0BoostAmount;
  innerItemBand0BoostAmount = new KConfigBaseEE::ItemDouble( currentGroup(), QStringLiteral( "band0BoostAmount" ), mBand0BoostAmount, 6 );
  itemBand0BoostAmount = new KConfigCompilerSignallingItem(innerItemBand0BoostAmount, this, notifyFunction, signalBand0BoostAmountChanged);
  innerItemBand0BoostAmount->setMinValue(-72);
  innerItemBand0BoostAmount->setMaxValue(72);
  itemBand0BoostAmount->setWriteFlags(KConfigBase::Notify);
  itemBand0BoostAmount->setGroup(cgMultibandCompressorinstanceIndex);
  addItem( itemBand0BoostAmount, QStringLiteral( "band0BoostAmount" ) );
  KConfigCompilerSignallingItem  *itemBand1BoostAmount;
  KConfigBaseEE::ItemDouble  *innerItemBand1BoostAmount;
  innerItemBand1BoostAmount = new KConfigBaseEE::ItemDouble( currentGroup(), QStringLiteral( "band1BoostAmount" ), mBand1BoostAmount, 6 );
  itemBand1BoostAmount = new KConfigCompilerSignallingItem(innerItemBand1BoostAmount, this, notifyFunction, signalBand1BoostAmountChanged);
  innerItemBand1BoostAmount->setMinValue(-72);
  innerItemBand1BoostAmount->setMaxValue(72);
  itemBand1BoostAmount->setWriteFlags(KConfigBase::Notify);
  itemBand1BoostAmount->setGroup(cgMultibandCompressorinstanceIndex);
  addItem( itemBand1BoostAmount, QStringLiteral( "band1BoostAmount" ) );
  KConfigCompilerSignallingItem  *itemBand2BoostAmount;
  KConfigBaseEE::ItemDouble  *innerItemBand2BoostAmount;
  innerItemBand2BoostAmount = new KConfigBaseEE::ItemDouble( currentGroup(), QStringLiteral( "band2BoostAmount" ), mBand2BoostAmount, 6 );
  itemBand2BoostAmount = new KConfigCompilerSignallingItem(innerItemBand2BoostAmount, this, notifyFunction, signalBand2BoostAmountChanged);
  innerItemBand2BoostAmount->setMinValue(-72);
  innerItemBand2BoostAmount->setMaxValue(72);
  itemBand2BoostAmount->setWriteFlags(KConfigBase::Notify);
  itemBand2BoostAmount->setGroup(cgMultibandCompressorinstanceIndex);
  addItem( itemBand2BoostAmount, QStringLiteral( "band2BoostAmount" ) );
  KConfigCompilerSignallingItem  *itemBand3BoostAmount;
  KConfigBaseEE::ItemDouble  *innerItemBand3BoostAmount;
  innerItemBand3BoostAmount = new KConfigBaseEE::ItemDouble( currentGroup(), QStringLiteral( "band3BoostAmount" ), mBand3BoostAmount, 6 );
  itemBand3BoostAmount = new KConfigCompilerSignallingItem(innerItemBand3BoostAmount, this, notifyFunction, signalBand3BoostAmountChanged);
  innerItemBand3BoostAmount->setMinValue(-72);
  innerItemBand3BoostAmount->setMaxValue(72);
  itemBand3BoostAmount->setWriteFlags(KConfigBase::Notify);
  itemBand3BoostAmount->setGroup(cgMultibandCompressorinstanceIndex);
  addItem( itemBand3BoostAmount, QStringLiteral( "band3BoostAmount" ) );
  KConfigCompilerSignallingItem  *itemBand4BoostAmount;
  KConfigBaseEE::ItemDouble  *innerItemBand4BoostAmount;
  innerItemBand4BoostAmount = new KConfigBaseEE::ItemDouble( currentGroup(), QStringLiteral( "band4BoostAmount" ), mBand4BoostAmount, 6 );
  itemBand4BoostAmount = new KConfigCompilerSignallingItem(innerItemBand4BoostAmount, this, notifyFunction, signalBand4BoostAmountChanged);
  innerItemBand4BoostAmount->setMinValue(-72);
  innerItemBand4BoostAmount->setMaxValue(72);
  itemBand4BoostAmount->setWriteFlags(KConfigBase::Notify);
  itemBand4BoostAmount->setGroup(cgMultibandCompressorinstanceIndex);
  addItem( itemBand4BoostAmount, QStringLiteral( "band4BoostAmount" ) );
  KConfigCompilerSignallingItem  *itemBand5BoostAmount;
  KConfigBaseEE::ItemDouble  *innerItemBand5BoostAmount;
  innerItemBand5BoostAmount = new KConfigBaseEE::ItemDouble( currentGroup(), QStringLiteral( "band5BoostAmount" ), mBand5BoostAmount, 6 );
  itemBand5BoostAmount = new KConfigCompilerSignallingItem(innerItemBand5BoostAmount, this, notifyFunction, signalBand5BoostAmountChanged);
  innerItemBand5BoostAmount->setMinValue(-72);
  innerItemBand5BoostAmount->setMaxValue(72);
  itemBand5BoostAmount->setWriteFlags(KConfigBase::Notify);
  itemBand5BoostAmount->setGroup(cgMultibandCompressorinstanceIndex);
  addItem( itemBand5BoostAmount, QStringLiteral( "band5BoostAmount" ) );
  KConfigCompilerSignallingItem  *itemBand6BoostAmount;
  KConfigBaseEE::ItemDouble  *innerItemBand6BoostAmount;
  innerItemBand6BoostAmount = new KConfigBaseEE::ItemDouble( currentGroup(), QStringLiteral( "band6BoostAmount" ), mBand6BoostAmount, 6 );
  itemBand6BoostAmount = new KConfigCompilerSignallingItem(innerItemBand6BoostAmount, this, notifyFunction, signalBand6BoostAmountChanged);
  innerItemBand6BoostAmount->setMinValue(-72);
  innerItemBand6BoostAmount->setMaxValue(72);
  itemBand6BoostAmount->setWriteFlags(KConfigBase::Notify);
  itemBand6BoostAmount->setGroup(cgMultibandCompressorinstanceIndex);
  addItem( itemBand6BoostAmount, QStringLiteral( "band6BoostAmount" ) );
  KConfigCompilerSignallingItem  *itemBand7BoostAmount;
  KConfigBaseEE::ItemDouble  *innerItemBand7BoostAmount;
  innerItemBand7BoostAmount = new KConfigBaseEE::ItemDouble( currentGroup(), QStringLiteral( "band7BoostAmount" ), mBand7BoostAmount, 6 );
  itemBand7BoostAmount = new KConfigCompilerSignallingItem(innerItemBand7BoostAmount, this, notifyFunction, signalBand7BoostAmountChanged);
  innerItemBand7BoostAmount->setMinValue(-72);
  innerItemBand7BoostAmount->setMaxValue(72);
  itemBand7BoostAmount->setWriteFlags(KConfigBase::Notify);
  itemBand7BoostAmount->setGroup(cgMultibandCompressorinstanceIndex);
  addItem( itemBand7BoostAmount, QStringLiteral( "band7BoostAmount" ) );
  KConfigCompilerSignallingItem  *itemBand0Makeup;
  KConfigBaseEE::ItemDouble  *innerItemBand0Makeup;
  innerItemBand0Makeup = new KConfigBaseEE::ItemDouble( currentGroup(), QStringLiteral( "band0Makeup" ), mBand0Makeup, 0 );
  itemBand0Makeup = new KConfigCompilerSignallingItem(innerItemBand0Makeup, this, notifyFunction, signalBand0MakeupChanged);
  innerItemBand0Makeup->setMinValue(-60);
  innerItemBand0Makeup->setMaxValue(60);
  itemBand0Makeup->setWriteFlags(KConfigBase::Notify);
  itemBand0Makeup->setGroup(cgMultibandCompressorinstanceIndex);
  addItem( itemBand0Makeup, QStringLiteral( "band0Makeup" ) );
  KConfigCompilerSignallingItem  *itemBand1Makeup;
  KConfigBaseEE::ItemDouble  *innerItemBand1Makeup;
  innerItemBand1Makeup = new KConfigBaseEE::ItemDouble( currentGroup(), QStringLiteral( "band1Makeup" ), mBand1Makeup, 0 );
  itemBand1Makeup = new KConfigCompilerSignallingItem(innerItemBand1Makeup, this, notifyFunction, signalBand1MakeupChanged);
  innerItemBand1Makeup->setMinValue(-60);
  innerItemBand1Makeup->setMaxValue(60);
  itemBand1Makeup->setWriteFlags(KConfigBase::Notify);
  itemBand1Makeup->setGroup(cgMultibandCompressorinstanceIndex);
  addItem( itemBand1Makeup, QStringLiteral( "band1Makeup" ) );
  KConfigCompilerSignallingItem  *itemBand2Makeup;
  KConfigBaseEE::ItemDouble  *innerItemBand2Makeup;
  innerItemBand2Makeup = new KConfigBaseEE::ItemDouble( currentGroup(), QStringLiteral( "band2Makeup" ), mBand2Makeup, 0 );
  itemBand2Makeup = new KConfigCompilerSignallingItem(innerItemBand2Makeup, this, notifyFunction, signalBand2MakeupChanged);
  innerItemBand2Makeup->setMinValue(-60);
  innerItemBand2Makeup->setMaxValue(60);
  itemBand2Makeup->setWriteFlags(KConfigBase::Notify);
  itemBand2Makeup->setGroup(cgMultibandCompressorinstanceIndex);
  addItem( itemBand2Makeup, QStringLiteral( "band2Makeup" ) );
  KConfigCompilerSignallingItem  *itemBand3Makeup;
  KConfigBaseEE::ItemDouble  *innerItemBand3Makeup;
  innerItemBand3Makeup = new KConfigBaseEE::ItemDouble( currentGroup(), QStringLiteral( "band3Makeup" ), mBand3Makeup, 0 );
  itemBand3Makeup = new KConfigCompilerSignallingItem(innerItemBand3Makeup, this, notifyFunction, signalBand3MakeupChanged);
  innerItemBand3Makeup->setMinValue(-60);
  innerItemBand3Makeup->setMaxValue(60);
  itemBand3Makeup->setWriteFlags(KConfigBase::Notify);
  itemBand3Makeup->setGroup(cgMultibandCompressorinstanceIndex);
  addItem( itemBand3Makeup, QStringLiteral( "band3Makeup" ) );
  KConfigCompilerSignallingItem  *itemBand4Makeup;
  KConfigBaseEE::ItemDouble  *innerItemBand4Makeup;
  innerItemBand4Makeup = new KConfigBaseEE::ItemDouble( currentGroup(), QStringLiteral( "band4Makeup" ), mBand4Makeup, 0 );
  itemBand4Makeup = new KConfigCompilerSignallingItem(innerItemBand4Makeup, this, notifyFunction, signalBand4MakeupChanged);
  innerItemBand4Makeup->setMinValue(-60);
  innerItemBand4Makeup->setMaxValue(60);
  itemBand4Makeup->setWriteFlags(KConfigBase::Notify);
  itemBand4Makeup->setGroup(cgMultibandCompressorinstanceIndex);
  addItem( itemBand4Makeup, QStringLiteral( "band4Makeup" ) );
  KConfigCompilerSignallingItem  *itemBand5Makeup;
  KConfigBaseEE::ItemDouble  *innerItemBand5Makeup;
  innerItemBand5Makeup = new KConfigBaseEE::ItemDouble( currentGroup(), QStringLiteral( "band5Makeup" ), mBand5Makeup, 0 );
  itemBand5Makeup = new KConfigCompilerSignallingItem(innerItemBand5Makeup, this, notifyFunction, signalBand5MakeupChanged);
  innerItemBand5Makeup->setMinValue(-60);
  innerItemBand5Makeup->setMaxValue(60);
  itemBand5Makeup->setWriteFlags(KConfigBase::Notify);
  itemBand5Makeup->setGroup(cgMultibandCompressorinstanceIndex);
  addItem( itemBand5Makeup, QStringLiteral( "band5Makeup" ) );
  KConfigCompilerSignallingItem  *itemBand6Makeup;
  KConfigBaseEE::ItemDouble  *innerItemBand6Makeup;
  innerItemBand6Makeup = new KConfigBaseEE::ItemDouble( currentGroup(), QStringLiteral( "band6Makeup" ), mBand6Makeup, 0 );
  itemBand6Makeup = new KConfigCompilerSignallingItem(innerItemBand6Makeup, this, notifyFunction, signalBand6MakeupChanged);
  innerItemBand6Makeup->setMinValue(-60);
  innerItemBand6Makeup->setMaxValue(60);
  itemBand6Makeup->setWriteFlags(KConfigBase::Notify);
  itemBand6Makeup->setGroup(cgMultibandCompressorinstanceIndex);
  addItem( itemBand6Makeup, QStringLiteral( "band6Makeup" ) );
  KConfigCompilerSignallingItem  *itemBand7Makeup;
  KConfigBaseEE::ItemDouble  *innerItemBand7Makeup;
  innerItemBand7Makeup = new KConfigBaseEE::ItemDouble( currentGroup(), QStringLiteral( "band7Makeup" ), mBand7Makeup, 0 );
  itemBand7Makeup = new KConfigCompilerSignallingItem(innerItemBand7Makeup, this, notifyFunction, signalBand7MakeupChanged);
  innerItemBand7Makeup->setMinValue(-60);
  innerItemBand7Makeup->setMaxValue(60);
  itemBand7Makeup->setWriteFlags(KConfigBase::Notify);
  itemBand7Makeup->setGroup(cgMultibandCompressorinstanceIndex);
  addItem( itemBand7Makeup, QStringLiteral( "band7Makeup" ) );
}

bool DbMultibandCompressor::defaultBypassValue_helper() const
{

  return false;
}

double DbMultibandCompressor::defaultInputGainValue_helper() const
{

  return 0;
}

double DbMultibandCompressor::defaultOutputGainValue_helper() const
{

  return 0;
}

double DbMultibandCompressor::defaultDryValue_helper() const
{

  return -80.01;
}

double DbMultibandCompressor::defaultWetValue_helper() const
{

  return 0;
}

bool DbMultibandCompressor::defaultViewSidechainValue_helper() const
{

  return false;
}

bool DbMultibandCompressor::defaultExternalSidechainEnabledValue_helper() const
{

  return false;
}

bool DbMultibandCompressor::defaultStereoSplitValue_helper() const
{

  return false;
}

QStringList DbMultibandCompressor::defaultCompressorModeLabelsValue_helper() const
{
  QStringList defaultcompressorModeLabels;
  defaultcompressorModeLabels.append( QString::fromUtf8( "Classic" ) );
  defaultcompressorModeLabels.append( QString::fromUtf8( "Modern" ) );
  defaultcompressorModeLabels.append( QString::fromUtf8( "Linear Phase" ) );

  return defaultcompressorModeLabels;
}

int DbMultibandCompressor::defaultCompressorModeValue_helper() const
{

  return 1;
}

QStringList DbMultibandCompressor::defaultEnvelopeBoostLabelsValue_helper() const
{
  QStringList defaultenvelopeBoostLabels;
  defaultenvelopeBoostLabels.append( QString::fromUtf8( "None" ) );
  defaultenvelopeBoostLabels.append( QString::fromUtf8( "Pink BT" ) );
  defaultenvelopeBoostLabels.append( QString::fromUtf8( "Pink MT" ) );
  defaultenvelopeBoostLabels.append( QString::fromUtf8( "Brown BT" ) );
  defaultenvelopeBoostLabels.append( QString::fromUtf8( "Brown MT" ) );

  return defaultenvelopeBoostLabels;
}

int DbMultibandCompressor::defaultEnvelopeBoostValue_helper() const
{

  return 0;
}

double DbMultibandCompressor::defaultInputToSidechainValue_helper() const
{

  return -80.01;
}

double DbMultibandCompressor::defaultInputToLinkValue_helper() const
{

  return -80.01;
}

double DbMultibandCompressor::defaultSidechainToInputValue_helper() const
{

  return -80.01;
}

double DbMultibandCompressor::defaultSidechainToLinkValue_helper() const
{

  return -80.01;
}

double DbMultibandCompressor::defaultLinkToSidechainValue_helper() const
{

  return -80.01;
}

double DbMultibandCompressor::defaultLinkToInputValue_helper() const
{

  return -80.01;
}

bool DbMultibandCompressor::defaultBand1EnableValue_helper() const
{

  return true;
}

bool DbMultibandCompressor::defaultBand2EnableValue_helper() const
{

  return true;
}

bool DbMultibandCompressor::defaultBand3EnableValue_helper() const
{

  return true;
}

bool DbMultibandCompressor::defaultBand4EnableValue_helper() const
{

  return false;
}

bool DbMultibandCompressor::defaultBand5EnableValue_helper() const
{

  return false;
}

bool DbMultibandCompressor::defaultBand6EnableValue_helper() const
{

  return false;
}

bool DbMultibandCompressor::defaultBand7EnableValue_helper() const
{

  return false;
}

double DbMultibandCompressor::defaultBand1SplitFrequencyValue_helper() const
{

  return 500;
}

double DbMultibandCompressor::defaultBand2SplitFrequencyValue_helper() const
{

  return 1000;
}

double DbMultibandCompressor::defaultBand3SplitFrequencyValue_helper() const
{

  return 2000;
}

double DbMultibandCompressor::defaultBand4SplitFrequencyValue_helper() const
{

  return 4000;
}

double DbMultibandCompressor::defaultBand5SplitFrequencyValue_helper() const
{

  return 8000;
}

double DbMultibandCompressor::defaultBand6SplitFrequencyValue_helper() const
{

  return 12000;
}

double DbMultibandCompressor::defaultBand7SplitFrequencyValue_helper() const
{

  return 16000;
}

QString DbMultibandCompressor::defaultSidechainInputDeviceValue_helper() const
{

  return QStringLiteral( "\"\"" );
}

QStringList DbMultibandCompressor::defaultSidechainTypeLabelsValue_helper() const
{
  QStringList defaultsidechainTypeLabels;
  defaultsidechainTypeLabels.append( QString::fromUtf8( "Internal" ) );
  defaultsidechainTypeLabels.append( QString::fromUtf8( "External" ) );
  defaultsidechainTypeLabels.append( QString::fromUtf8( "Link" ) );

  return defaultsidechainTypeLabels;
}

int DbMultibandCompressor::defaultBand0SidechainTypeValue_helper() const
{

  return 0;
}

int DbMultibandCompressor::defaultBand1SidechainTypeValue_helper() const
{

  return 0;
}

int DbMultibandCompressor::defaultBand2SidechainTypeValue_helper() const
{

  return 0;
}

int DbMultibandCompressor::defaultBand3SidechainTypeValue_helper() const
{

  return 0;
}

int DbMultibandCompressor::defaultBand4SidechainTypeValue_helper() const
{

  return 0;
}

int DbMultibandCompressor::defaultBand5SidechainTypeValue_helper() const
{

  return 0;
}

int DbMultibandCompressor::defaultBand6SidechainTypeValue_helper() const
{

  return 0;
}

int DbMultibandCompressor::defaultBand7SidechainTypeValue_helper() const
{

  return 0;
}

QStringList DbMultibandCompressor::defaultSidechainModeLabelsValue_helper() const
{
  QStringList defaultsidechainModeLabels;
  defaultsidechainModeLabels.append( QString::fromUtf8( "Peak" ) );
  defaultsidechainModeLabels.append( QString::fromUtf8( "RMS" ) );
  defaultsidechainModeLabels.append( QString::fromUtf8( "LPF" ) );
  defaultsidechainModeLabels.append( QString::fromUtf8( "SMA" ) );

  return defaultsidechainModeLabels;
}

int DbMultibandCompressor::defaultBand0SidechainModeValue_helper() const
{

  return 1;
}

int DbMultibandCompressor::defaultBand1SidechainModeValue_helper() const
{

  return 1;
}

int DbMultibandCompressor::defaultBand2SidechainModeValue_helper() const
{

  return 1;
}

int DbMultibandCompressor::defaultBand3SidechainModeValue_helper() const
{

  return 1;
}

int DbMultibandCompressor::defaultBand4SidechainModeValue_helper() const
{

  return 1;
}

int DbMultibandCompressor::defaultBand5SidechainModeValue_helper() const
{

  return 1;
}

int DbMultibandCompressor::defaultBand6SidechainModeValue_helper() const
{

  return 1;
}

int DbMultibandCompressor::defaultBand7SidechainModeValue_helper() const
{

  return 1;
}

QStringList DbMultibandCompressor::defaultSidechainSourceLabelsValue_helper() const
{
  QStringList defaultsidechainSourceLabels;
  defaultsidechainSourceLabels.append( QString::fromUtf8( "Middle" ) );
  defaultsidechainSourceLabels.append( QString::fromUtf8( "Side" ) );
  defaultsidechainSourceLabels.append( QString::fromUtf8( "Left" ) );
  defaultsidechainSourceLabels.append( QString::fromUtf8( "Right" ) );
  defaultsidechainSourceLabels.append( QString::fromUtf8( "Min" ) );
  defaultsidechainSourceLabels.append( QString::fromUtf8( "Max" ) );

  return defaultsidechainSourceLabels;
}

int DbMultibandCompressor::defaultBand0SidechainSourceValue_helper() const
{

  return 0;
}

int DbMultibandCompressor::defaultBand1SidechainSourceValue_helper() const
{

  return 0;
}

int DbMultibandCompressor::defaultBand2SidechainSourceValue_helper() const
{

  return 0;
}

int DbMultibandCompressor::defaultBand3SidechainSourceValue_helper() const
{

  return 0;
}

int DbMultibandCompressor::defaultBand4SidechainSourceValue_helper() const
{

  return 0;
}

int DbMultibandCompressor::defaultBand5SidechainSourceValue_helper() const
{

  return 0;
}

int DbMultibandCompressor::defaultBand6SidechainSourceValue_helper() const
{

  return 0;
}

int DbMultibandCompressor::defaultBand7SidechainSourceValue_helper() const
{

  return 0;
}

QStringList DbMultibandCompressor::defaultStereoSplitSourceLabelsValue_helper() const
{
  QStringList defaultstereoSplitSourceLabels;
  defaultstereoSplitSourceLabels.append( QString::fromUtf8( "Left/Right" ) );
  defaultstereoSplitSourceLabels.append( QString::fromUtf8( "Right/Left" ) );
  defaultstereoSplitSourceLabels.append( QString::fromUtf8( "Mid/Side" ) );
  defaultstereoSplitSourceLabels.append( QString::fromUtf8( "Side/Mid" ) );
  defaultstereoSplitSourceLabels.append( QString::fromUtf8( "Min" ) );
  defaultstereoSplitSourceLabels.append( QString::fromUtf8( "Max" ) );

  return defaultstereoSplitSourceLabels;
}

int DbMultibandCompressor::defaultBand0StereoSplitSourceValue_helper() const
{

  return 0;
}

int DbMultibandCompressor::defaultBand1StereoSplitSourceValue_helper() const
{

  return 0;
}

int DbMultibandCompressor::defaultBand2StereoSplitSourceValue_helper() const
{

  return 0;
}

int DbMultibandCompressor::defaultBand3StereoSplitSourceValue_helper() const
{

  return 0;
}

int DbMultibandCompressor::defaultBand4StereoSplitSourceValue_helper() const
{

  return 0;
}

int DbMultibandCompressor::defaultBand5StereoSplitSourceValue_helper() const
{

  return 0;
}

int DbMultibandCompressor::defaultBand6StereoSplitSourceValue_helper() const
{

  return 0;
}

int DbMultibandCompressor::defaultBand7StereoSplitSourceValue_helper() const
{

  return 0;
}

double DbMultibandCompressor::defaultBand0SidechainLookaheadValue_helper() const
{

  return 0;
}

double DbMultibandCompressor::defaultBand1SidechainLookaheadValue_helper() const
{

  return 0;
}

double DbMultibandCompressor::defaultBand2SidechainLookaheadValue_helper() const
{

  return 0;
}

double DbMultibandCompressor::defaultBand3SidechainLookaheadValue_helper() const
{

  return 0;
}

double DbMultibandCompressor::defaultBand4SidechainLookaheadValue_helper() const
{

  return 0;
}

double DbMultibandCompressor::defaultBand5SidechainLookaheadValue_helper() const
{

  return 0;
}

double DbMultibandCompressor::defaultBand6SidechainLookaheadValue_helper() const
{

  return 0;
}

double DbMultibandCompressor::defaultBand7SidechainLookaheadValue_helper() const
{

  return 0;
}

double DbMultibandCompressor::defaultBand0SidechainReactivityValue_helper() const
{

  return 10;
}

double DbMultibandCompressor::defaultBand1SidechainReactivityValue_helper() const
{

  return 10;
}

double DbMultibandCompressor::defaultBand2SidechainReactivityValue_helper() const
{

  return 10;
}

double DbMultibandCompressor::defaultBand3SidechainReactivityValue_helper() const
{

  return 10;
}

double DbMultibandCompressor::defaultBand4SidechainReactivityValue_helper() const
{

  return 10;
}

double DbMultibandCompressor::defaultBand5SidechainReactivityValue_helper() const
{

  return 10;
}

double DbMultibandCompressor::defaultBand6SidechainReactivityValue_helper() const
{

  return 10;
}

double DbMultibandCompressor::defaultBand7SidechainReactivityValue_helper() const
{

  return 10;
}

double DbMultibandCompressor::defaultBand0SidechainPreampValue_helper() const
{

  return 0;
}

double DbMultibandCompressor::defaultBand1SidechainPreampValue_helper() const
{

  return 0;
}

double DbMultibandCompressor::defaultBand2SidechainPreampValue_helper() const
{

  return 0;
}

double DbMultibandCompressor::defaultBand3SidechainPreampValue_helper() const
{

  return 0;
}

double DbMultibandCompressor::defaultBand4SidechainPreampValue_helper() const
{

  return 0;
}

double DbMultibandCompressor::defaultBand5SidechainPreampValue_helper() const
{

  return 0;
}

double DbMultibandCompressor::defaultBand6SidechainPreampValue_helper() const
{

  return 0;
}

double DbMultibandCompressor::defaultBand7SidechainPreampValue_helper() const
{

  return 0;
}

bool DbMultibandCompressor::defaultBand0SidechainCustomLowcutFilterValue_helper() const
{

  return false;
}

bool DbMultibandCompressor::defaultBand1SidechainCustomLowcutFilterValue_helper() const
{

  return false;
}

bool DbMultibandCompressor::defaultBand2SidechainCustomLowcutFilterValue_helper() const
{

  return false;
}

bool DbMultibandCompressor::defaultBand3SidechainCustomLowcutFilterValue_helper() const
{

  return false;
}

bool DbMultibandCompressor::defaultBand4SidechainCustomLowcutFilterValue_helper() const
{

  return false;
}

bool DbMultibandCompressor::defaultBand5SidechainCustomLowcutFilterValue_helper() const
{

  return false;
}

bool DbMultibandCompressor::defaultBand6SidechainCustomLowcutFilterValue_helper() const
{

  return false;
}

bool DbMultibandCompressor::defaultBand7SidechainCustomLowcutFilterValue_helper() const
{

  return false;
}

bool DbMultibandCompressor::defaultBand0SidechainCustomHighcutFilterValue_helper() const
{

  return false;
}

bool DbMultibandCompressor::defaultBand1SidechainCustomHighcutFilterValue_helper() const
{

  return false;
}

bool DbMultibandCompressor::defaultBand2SidechainCustomHighcutFilterValue_helper() const
{

  return false;
}

bool DbMultibandCompressor::defaultBand3SidechainCustomHighcutFilterValue_helper() const
{

  return false;
}

bool DbMultibandCompressor::defaultBand4SidechainCustomHighcutFilterValue_helper() const
{

  return false;
}

bool DbMultibandCompressor::defaultBand5SidechainCustomHighcutFilterValue_helper() const
{

  return false;
}

bool DbMultibandCompressor::defaultBand6SidechainCustomHighcutFilterValue_helper() const
{

  return false;
}

bool DbMultibandCompressor::defaultBand7SidechainCustomHighcutFilterValue_helper() const
{

  return false;
}

double DbMultibandCompressor::defaultBand0SidechainLowcutFrequencyValue_helper() const
{

  return 10;
}

double DbMultibandCompressor::defaultBand1SidechainLowcutFrequencyValue_helper() const
{

  return 500;
}

double DbMultibandCompressor::defaultBand2SidechainLowcutFrequencyValue_helper() const
{

  return 1000;
}

double DbMultibandCompressor::defaultBand3SidechainLowcutFrequencyValue_helper() const
{

  return 2000;
}

double DbMultibandCompressor::defaultBand4SidechainLowcutFrequencyValue_helper() const
{

  return 4000;
}

double DbMultibandCompressor::defaultBand5SidechainLowcutFrequencyValue_helper() const
{

  return 8000;
}

double DbMultibandCompressor::defaultBand6SidechainLowcutFrequencyValue_helper() const
{

  return 12000;
}

double DbMultibandCompressor::defaultBand7SidechainLowcutFrequencyValue_helper() const
{

  return 16000;
}

double DbMultibandCompressor::defaultBand0SidechainHighcutFrequencyValue_helper() const
{

  return 500;
}

double DbMultibandCompressor::defaultBand1SidechainHighcutFrequencyValue_helper() const
{

  return 1000;
}

double DbMultibandCompressor::defaultBand2SidechainHighcutFrequencyValue_helper() const
{

  return 2000;
}

double DbMultibandCompressor::defaultBand3SidechainHighcutFrequencyValue_helper() const
{

  return 4000;
}

double DbMultibandCompressor::defaultBand4SidechainHighcutFrequencyValue_helper() const
{

  return 8000;
}

double DbMultibandCompressor::defaultBand5SidechainHighcutFrequencyValue_helper() const
{

  return 12000;
}

double DbMultibandCompressor::defaultBand6SidechainHighcutFrequencyValue_helper() const
{

  return 16000;
}

double DbMultibandCompressor::defaultBand7SidechainHighcutFrequencyValue_helper() const
{

  return 20000;
}

QStringList DbMultibandCompressor::defaultCompressionModeLabelsValue_helper() const
{
  QStringList defaultcompressionModeLabels;
  defaultcompressionModeLabels.append( QString::fromUtf8( "Downward" ) );
  defaultcompressionModeLabels.append( QString::fromUtf8( "Upward" ) );
  defaultcompressionModeLabels.append( QString::fromUtf8( "Boosting" ) );

  return defaultcompressionModeLabels;
}

int DbMultibandCompressor::defaultBand0CompressionModeValue_helper() const
{

  return 0;
}

int DbMultibandCompressor::defaultBand1CompressionModeValue_helper() const
{

  return 0;
}

int DbMultibandCompressor::defaultBand2CompressionModeValue_helper() const
{

  return 0;
}

int DbMultibandCompressor::defaultBand3CompressionModeValue_helper() const
{

  return 0;
}

int DbMultibandCompressor::defaultBand4CompressionModeValue_helper() const
{

  return 0;
}

int DbMultibandCompressor::defaultBand5CompressionModeValue_helper() const
{

  return 0;
}

int DbMultibandCompressor::defaultBand6CompressionModeValue_helper() const
{

  return 0;
}

int DbMultibandCompressor::defaultBand7CompressionModeValue_helper() const
{

  return 0;
}

bool DbMultibandCompressor::defaultBand0CompressorEnableValue_helper() const
{

  return true;
}

bool DbMultibandCompressor::defaultBand1CompressorEnableValue_helper() const
{

  return true;
}

bool DbMultibandCompressor::defaultBand2CompressorEnableValue_helper() const
{

  return true;
}

bool DbMultibandCompressor::defaultBand3CompressorEnableValue_helper() const
{

  return true;
}

bool DbMultibandCompressor::defaultBand4CompressorEnableValue_helper() const
{

  return true;
}

bool DbMultibandCompressor::defaultBand5CompressorEnableValue_helper() const
{

  return true;
}

bool DbMultibandCompressor::defaultBand6CompressorEnableValue_helper() const
{

  return true;
}

bool DbMultibandCompressor::defaultBand7CompressorEnableValue_helper() const
{

  return true;
}

bool DbMultibandCompressor::defaultBand0SoloValue_helper() const
{

  return false;
}

bool DbMultibandCompressor::defaultBand1SoloValue_helper() const
{

  return false;
}

bool DbMultibandCompressor::defaultBand2SoloValue_helper() const
{

  return false;
}

bool DbMultibandCompressor::defaultBand3SoloValue_helper() const
{

  return false;
}

bool DbMultibandCompressor::defaultBand4SoloValue_helper() const
{

  return false;
}

bool DbMultibandCompressor::defaultBand5SoloValue_helper() const
{

  return false;
}

bool DbMultibandCompressor::defaultBand6SoloValue_helper() const
{

  return false;
}

bool DbMultibandCompressor::defaultBand7SoloValue_helper() const
{

  return false;
}

bool DbMultibandCompressor::defaultBand0MuteValue_helper() const
{

  return false;
}

bool DbMultibandCompressor::defaultBand1MuteValue_helper() const
{

  return false;
}

bool DbMultibandCompressor::defaultBand2MuteValue_helper() const
{

  return false;
}

bool DbMultibandCompressor::defaultBand3MuteValue_helper() const
{

  return false;
}

bool DbMultibandCompressor::defaultBand4MuteValue_helper() const
{

  return false;
}

bool DbMultibandCompressor::defaultBand5MuteValue_helper() const
{

  return false;
}

bool DbMultibandCompressor::defaultBand6MuteValue_helper() const
{

  return false;
}

bool DbMultibandCompressor::defaultBand7MuteValue_helper() const
{

  return false;
}

double DbMultibandCompressor::defaultBand0AttackThresholdValue_helper() const
{

  return -12;
}

double DbMultibandCompressor::defaultBand1AttackThresholdValue_helper() const
{

  return -12;
}

double DbMultibandCompressor::defaultBand2AttackThresholdValue_helper() const
{

  return -12;
}

double DbMultibandCompressor::defaultBand3AttackThresholdValue_helper() const
{

  return -12;
}

double DbMultibandCompressor::defaultBand4AttackThresholdValue_helper() const
{

  return -12;
}

double DbMultibandCompressor::defaultBand5AttackThresholdValue_helper() const
{

  return -12;
}

double DbMultibandCompressor::defaultBand6AttackThresholdValue_helper() const
{

  return -12;
}

double DbMultibandCompressor::defaultBand7AttackThresholdValue_helper() const
{

  return -12;
}

double DbMultibandCompressor::defaultBand0AttackTimeValue_helper() const
{

  return 20;
}

double DbMultibandCompressor::defaultBand1AttackTimeValue_helper() const
{

  return 20;
}

double DbMultibandCompressor::defaultBand2AttackTimeValue_helper() const
{

  return 20;
}

double DbMultibandCompressor::defaultBand3AttackTimeValue_helper() const
{

  return 20;
}

double DbMultibandCompressor::defaultBand4AttackTimeValue_helper() const
{

  return 20;
}

double DbMultibandCompressor::defaultBand5AttackTimeValue_helper() const
{

  return 20;
}

double DbMultibandCompressor::defaultBand6AttackTimeValue_helper() const
{

  return 20;
}

double DbMultibandCompressor::defaultBand7AttackTimeValue_helper() const
{

  return 20;
}

double DbMultibandCompressor::defaultBand0ReleaseThresholdValue_helper() const
{

  return -80.01;
}

double DbMultibandCompressor::defaultBand1ReleaseThresholdValue_helper() const
{

  return -80.01;
}

double DbMultibandCompressor::defaultBand2ReleaseThresholdValue_helper() const
{

  return -80.01;
}

double DbMultibandCompressor::defaultBand3ReleaseThresholdValue_helper() const
{

  return -80.01;
}

double DbMultibandCompressor::defaultBand4ReleaseThresholdValue_helper() const
{

  return -80.01;
}

double DbMultibandCompressor::defaultBand5ReleaseThresholdValue_helper() const
{

  return -80.01;
}

double DbMultibandCompressor::defaultBand6ReleaseThresholdValue_helper() const
{

  return -80.01;
}

double DbMultibandCompressor::defaultBand7ReleaseThresholdValue_helper() const
{

  return -80.01;
}

double DbMultibandCompressor::defaultBand0ReleaseTimeValue_helper() const
{

  return 100;
}

double DbMultibandCompressor::defaultBand1ReleaseTimeValue_helper() const
{

  return 100;
}

double DbMultibandCompressor::defaultBand2ReleaseTimeValue_helper() const
{

  return 100;
}

double DbMultibandCompressor::defaultBand3ReleaseTimeValue_helper() const
{

  return 100;
}

double DbMultibandCompressor::defaultBand4ReleaseTimeValue_helper() const
{

  return 100;
}

double DbMultibandCompressor::defaultBand5ReleaseTimeValue_helper() const
{

  return 100;
}

double DbMultibandCompressor::defaultBand6ReleaseTimeValue_helper() const
{

  return 100;
}

double DbMultibandCompressor::defaultBand7ReleaseTimeValue_helper() const
{

  return 100;
}

double DbMultibandCompressor::defaultBand0RatioValue_helper() const
{

  return 1;
}

double DbMultibandCompressor::defaultBand1RatioValue_helper() const
{

  return 1;
}

double DbMultibandCompressor::defaultBand2RatioValue_helper() const
{

  return 1;
}

double DbMultibandCompressor::defaultBand3RatioValue_helper() const
{

  return 1;
}

double DbMultibandCompressor::defaultBand4RatioValue_helper() const
{

  return 1;
}

double DbMultibandCompressor::defaultBand5RatioValue_helper() const
{

  return 1;
}

double DbMultibandCompressor::defaultBand6RatioValue_helper() const
{

  return 1;
}

double DbMultibandCompressor::defaultBand7RatioValue_helper() const
{

  return 1;
}

double DbMultibandCompressor::defaultBand0KneeValue_helper() const
{

  return -6;
}

double DbMultibandCompressor::defaultBand1KneeValue_helper() const
{

  return -6;
}

double DbMultibandCompressor::defaultBand2KneeValue_helper() const
{

  return -6;
}

double DbMultibandCompressor::defaultBand3KneeValue_helper() const
{

  return -6;
}

double DbMultibandCompressor::defaultBand4KneeValue_helper() const
{

  return -6;
}

double DbMultibandCompressor::defaultBand5KneeValue_helper() const
{

  return -6;
}

double DbMultibandCompressor::defaultBand6KneeValue_helper() const
{

  return -6;
}

double DbMultibandCompressor::defaultBand7KneeValue_helper() const
{

  return -6;
}

double DbMultibandCompressor::defaultBand0BoostThresholdValue_helper() const
{

  return -72;
}

double DbMultibandCompressor::defaultBand1BoostThresholdValue_helper() const
{

  return -72;
}

double DbMultibandCompressor::defaultBand2BoostThresholdValue_helper() const
{

  return -72;
}

double DbMultibandCompressor::defaultBand3BoostThresholdValue_helper() const
{

  return -72;
}

double DbMultibandCompressor::defaultBand4BoostThresholdValue_helper() const
{

  return -72;
}

double DbMultibandCompressor::defaultBand5BoostThresholdValue_helper() const
{

  return -72;
}

double DbMultibandCompressor::defaultBand6BoostThresholdValue_helper() const
{

  return -72;
}

double DbMultibandCompressor::defaultBand7BoostThresholdValue_helper() const
{

  return -72;
}

double DbMultibandCompressor::defaultBand0BoostAmountValue_helper() const
{

  return 6;
}

double DbMultibandCompressor::defaultBand1BoostAmountValue_helper() const
{

  return 6;
}

double DbMultibandCompressor::defaultBand2BoostAmountValue_helper() const
{

  return 6;
}

double DbMultibandCompressor::defaultBand3BoostAmountValue_helper() const
{

  return 6;
}

double DbMultibandCompressor::defaultBand4BoostAmountValue_helper() const
{

  return 6;
}

double DbMultibandCompressor::defaultBand5BoostAmountValue_helper() const
{

  return 6;
}

double DbMultibandCompressor::defaultBand6BoostAmountValue_helper() const
{

  return 6;
}

double DbMultibandCompressor::defaultBand7BoostAmountValue_helper() const
{

  return 6;
}

double DbMultibandCompressor::defaultBand0MakeupValue_helper() const
{

  return 0;
}

double DbMultibandCompressor::defaultBand1MakeupValue_helper() const
{

  return 0;
}

double DbMultibandCompressor::defaultBand2MakeupValue_helper() const
{

  return 0;
}

double DbMultibandCompressor::defaultBand3MakeupValue_helper() const
{

  return 0;
}

double DbMultibandCompressor::defaultBand4MakeupValue_helper() const
{

  return 0;
}

double DbMultibandCompressor::defaultBand5MakeupValue_helper() const
{

  return 0;
}

double DbMultibandCompressor::defaultBand6MakeupValue_helper() const
{

  return 0;
}

double DbMultibandCompressor::defaultBand7MakeupValue_helper() const
{

  return 0;
}

DbMultibandCompressor::~DbMultibandCompressor()
{
}


void DbMultibandCompressor::itemChanged(quint64 signalFlag) {

  switch (signalFlag) {
  case signalBypassChanged:
    Q_EMIT bypassChanged();
    break;
  case signalInputGainChanged:
    Q_EMIT inputGainChanged();
    break;
  case signalOutputGainChanged:
    Q_EMIT outputGainChanged();
    break;
  case signalDryChanged:
    Q_EMIT dryChanged();
    break;
  case signalWetChanged:
    Q_EMIT wetChanged();
    break;
  case signalViewSidechainChanged:
    Q_EMIT viewSidechainChanged();
    break;
  case signalExternalSidechainEnabledChanged:
    Q_EMIT externalSidechainEnabledChanged();
    break;
  case signalStereoSplitChanged:
    Q_EMIT stereoSplitChanged();
    break;
  case signalCompressorModeLabelsChanged:
    Q_EMIT compressorModeLabelsChanged();
    break;
  case signalCompressorModeChanged:
    Q_EMIT compressorModeChanged();
    break;
  case signalEnvelopeBoostLabelsChanged:
    Q_EMIT envelopeBoostLabelsChanged();
    break;
  case signalEnvelopeBoostChanged:
    Q_EMIT envelopeBoostChanged();
    break;
  case signalInputToSidechainChanged:
    Q_EMIT inputToSidechainChanged();
    break;
  case signalInputToLinkChanged:
    Q_EMIT inputToLinkChanged();
    break;
  case signalSidechainToInputChanged:
    Q_EMIT sidechainToInputChanged();
    break;
  case signalSidechainToLinkChanged:
    Q_EMIT sidechainToLinkChanged();
    break;
  case signalLinkToSidechainChanged:
    Q_EMIT linkToSidechainChanged();
    break;
  case signalLinkToInputChanged:
    Q_EMIT linkToInputChanged();
    break;
  case signalBand1EnableChanged:
    Q_EMIT band1EnableChanged();
    break;
  case signalBand2EnableChanged:
    Q_EMIT band2EnableChanged();
    break;
  case signalBand3EnableChanged:
    Q_EMIT band3EnableChanged();
    break;
  case signalBand4EnableChanged:
    Q_EMIT band4EnableChanged();
    break;
  case signalBand5EnableChanged:
    Q_EMIT band5EnableChanged();
    break;
  case signalBand6EnableChanged:
    Q_EMIT band6EnableChanged();
    break;
  case signalBand7EnableChanged:
    Q_EMIT band7EnableChanged();
    break;
  case signalBand1SplitFrequencyChanged:
    Q_EMIT band1SplitFrequencyChanged();
    break;
  case signalBand2SplitFrequencyChanged:
    Q_EMIT band2SplitFrequencyChanged();
    break;
  case signalBand3SplitFrequencyChanged:
    Q_EMIT band3SplitFrequencyChanged();
    break;
  case signalBand4SplitFrequencyChanged:
    Q_EMIT band4SplitFrequencyChanged();
    break;
  case signalBand5SplitFrequencyChanged:
    Q_EMIT band5SplitFrequencyChanged();
    break;
  case signalBand6SplitFrequencyChanged:
    Q_EMIT band6SplitFrequencyChanged();
    break;
  case signalBand7SplitFrequencyChanged:
    Q_EMIT band7SplitFrequencyChanged();
    break;
  case signalSidechainInputDeviceChanged:
    Q_EMIT sidechainInputDeviceChanged();
    break;
  case signalSidechainTypeLabelsChanged:
    Q_EMIT sidechainTypeLabelsChanged();
    break;
  case signalBand0SidechainTypeChanged:
    Q_EMIT band0SidechainTypeChanged();
    break;
  case signalBand1SidechainTypeChanged:
    Q_EMIT band1SidechainTypeChanged();
    break;
  case signalBand2SidechainTypeChanged:
    Q_EMIT band2SidechainTypeChanged();
    break;
  case signalBand3SidechainTypeChanged:
    Q_EMIT band3SidechainTypeChanged();
    break;
  case signalBand4SidechainTypeChanged:
    Q_EMIT band4SidechainTypeChanged();
    break;
  case signalBand5SidechainTypeChanged:
    Q_EMIT band5SidechainTypeChanged();
    break;
  case signalBand6SidechainTypeChanged:
    Q_EMIT band6SidechainTypeChanged();
    break;
  case signalBand7SidechainTypeChanged:
    Q_EMIT band7SidechainTypeChanged();
    break;
  case signalSidechainModeLabelsChanged:
    Q_EMIT sidechainModeLabelsChanged();
    break;
  case signalBand0SidechainModeChanged:
    Q_EMIT band0SidechainModeChanged();
    break;
  case signalBand1SidechainModeChanged:
    Q_EMIT band1SidechainModeChanged();
    break;
  case signalBand2SidechainModeChanged:
    Q_EMIT band2SidechainModeChanged();
    break;
  case signalBand3SidechainModeChanged:
    Q_EMIT band3SidechainModeChanged();
    break;
  case signalBand4SidechainModeChanged:
    Q_EMIT band4SidechainModeChanged();
    break;
  case signalBand5SidechainModeChanged:
    Q_EMIT band5SidechainModeChanged();
    break;
  case signalBand6SidechainModeChanged:
    Q_EMIT band6SidechainModeChanged();
    break;
  case signalBand7SidechainModeChanged:
    Q_EMIT band7SidechainModeChanged();
    break;
  case signalSidechainSourceLabelsChanged:
    Q_EMIT sidechainSourceLabelsChanged();
    break;
  case signalBand0SidechainSourceChanged:
    Q_EMIT band0SidechainSourceChanged();
    break;
  case signalBand1SidechainSourceChanged:
    Q_EMIT band1SidechainSourceChanged();
    break;
  case signalBand2SidechainSourceChanged:
    Q_EMIT band2SidechainSourceChanged();
    break;
  case signalBand3SidechainSourceChanged:
    Q_EMIT band3SidechainSourceChanged();
    break;
  case signalBand4SidechainSourceChanged:
    Q_EMIT band4SidechainSourceChanged();
    break;
  case signalBand5SidechainSourceChanged:
    Q_EMIT band5SidechainSourceChanged();
    break;
  case signalBand6SidechainSourceChanged:
    Q_EMIT band6SidechainSourceChanged();
    break;
  case signalBand7SidechainSourceChanged:
    Q_EMIT band7SidechainSourceChanged();
    break;
  case signalStereoSplitSourceLabelsChanged:
    Q_EMIT stereoSplitSourceLabelsChanged();
    break;
  case signalBand0StereoSplitSourceChanged:
    Q_EMIT band0StereoSplitSourceChanged();
    break;
  case signalBand1StereoSplitSourceChanged:
    Q_EMIT band1StereoSplitSourceChanged();
    break;
  case signalBand2StereoSplitSourceChanged:
    Q_EMIT band2StereoSplitSourceChanged();
    break;
  case signalBand3StereoSplitSourceChanged:
    Q_EMIT band3StereoSplitSourceChanged();
    break;
  case signalBand4StereoSplitSourceChanged:
    Q_EMIT band4StereoSplitSourceChanged();
    break;
  case signalBand5StereoSplitSourceChanged:
    Q_EMIT band5StereoSplitSourceChanged();
    break;
  case signalBand6StereoSplitSourceChanged:
    Q_EMIT band6StereoSplitSourceChanged();
    break;
  case signalBand7StereoSplitSourceChanged:
    Q_EMIT band7StereoSplitSourceChanged();
    break;
  case signalBand0SidechainLookaheadChanged:
    Q_EMIT band0SidechainLookaheadChanged();
    break;
  case signalBand1SidechainLookaheadChanged:
    Q_EMIT band1SidechainLookaheadChanged();
    break;
  case signalBand2SidechainLookaheadChanged:
    Q_EMIT band2SidechainLookaheadChanged();
    break;
  case signalBand3SidechainLookaheadChanged:
    Q_EMIT band3SidechainLookaheadChanged();
    break;
  case signalBand4SidechainLookaheadChanged:
    Q_EMIT band4SidechainLookaheadChanged();
    break;
  case signalBand5SidechainLookaheadChanged:
    Q_EMIT band5SidechainLookaheadChanged();
    break;
  case signalBand6SidechainLookaheadChanged:
    Q_EMIT band6SidechainLookaheadChanged();
    break;
  case signalBand7SidechainLookaheadChanged:
    Q_EMIT band7SidechainLookaheadChanged();
    break;
  case signalBand0SidechainReactivityChanged:
    Q_EMIT band0SidechainReactivityChanged();
    break;
  case signalBand1SidechainReactivityChanged:
    Q_EMIT band1SidechainReactivityChanged();
    break;
  case signalBand2SidechainReactivityChanged:
    Q_EMIT band2SidechainReactivityChanged();
    break;
  case signalBand3SidechainReactivityChanged:
    Q_EMIT band3SidechainReactivityChanged();
    break;
  case signalBand4SidechainReactivityChanged:
    Q_EMIT band4SidechainReactivityChanged();
    break;
  case signalBand5SidechainReactivityChanged:
    Q_EMIT band5SidechainReactivityChanged();
    break;
  case signalBand6SidechainReactivityChanged:
    Q_EMIT band6SidechainReactivityChanged();
    break;
  case signalBand7SidechainReactivityChanged:
    Q_EMIT band7SidechainReactivityChanged();
    break;
  case signalBand0SidechainPreampChanged:
    Q_EMIT band0SidechainPreampChanged();
    break;
  case signalBand1SidechainPreampChanged:
    Q_EMIT band1SidechainPreampChanged();
    break;
  case signalBand2SidechainPreampChanged:
    Q_EMIT band2SidechainPreampChanged();
    break;
  case signalBand3SidechainPreampChanged:
    Q_EMIT band3SidechainPreampChanged();
    break;
  case signalBand4SidechainPreampChanged:
    Q_EMIT band4SidechainPreampChanged();
    break;
  case signalBand5SidechainPreampChanged:
    Q_EMIT band5SidechainPreampChanged();
    break;
  case signalBand6SidechainPreampChanged:
    Q_EMIT band6SidechainPreampChanged();
    break;
  case signalBand7SidechainPreampChanged:
    Q_EMIT band7SidechainPreampChanged();
    break;
  case signalBand0SidechainCustomLowcutFilterChanged:
    Q_EMIT band0SidechainCustomLowcutFilterChanged();
    break;
  case signalBand1SidechainCustomLowcutFilterChanged:
    Q_EMIT band1SidechainCustomLowcutFilterChanged();
    break;
  case signalBand2SidechainCustomLowcutFilterChanged:
    Q_EMIT band2SidechainCustomLowcutFilterChanged();
    break;
  case signalBand3SidechainCustomLowcutFilterChanged:
    Q_EMIT band3SidechainCustomLowcutFilterChanged();
    break;
  case signalBand4SidechainCustomLowcutFilterChanged:
    Q_EMIT band4SidechainCustomLowcutFilterChanged();
    break;
  case signalBand5SidechainCustomLowcutFilterChanged:
    Q_EMIT band5SidechainCustomLowcutFilterChanged();
    break;
  case signalBand6SidechainCustomLowcutFilterChanged:
    Q_EMIT band6SidechainCustomLowcutFilterChanged();
    break;
  case signalBand7SidechainCustomLowcutFilterChanged:
    Q_EMIT band7SidechainCustomLowcutFilterChanged();
    break;
  case signalBand0SidechainCustomHighcutFilterChanged:
    Q_EMIT band0SidechainCustomHighcutFilterChanged();
    break;
  case signalBand1SidechainCustomHighcutFilterChanged:
    Q_EMIT band1SidechainCustomHighcutFilterChanged();
    break;
  case signalBand2SidechainCustomHighcutFilterChanged:
    Q_EMIT band2SidechainCustomHighcutFilterChanged();
    break;
  case signalBand3SidechainCustomHighcutFilterChanged:
    Q_EMIT band3SidechainCustomHighcutFilterChanged();
    break;
  case signalBand4SidechainCustomHighcutFilterChanged:
    Q_EMIT band4SidechainCustomHighcutFilterChanged();
    break;
  case signalBand5SidechainCustomHighcutFilterChanged:
    Q_EMIT band5SidechainCustomHighcutFilterChanged();
    break;
  case signalBand6SidechainCustomHighcutFilterChanged:
    Q_EMIT band6SidechainCustomHighcutFilterChanged();
    break;
  case signalBand7SidechainCustomHighcutFilterChanged:
    Q_EMIT band7SidechainCustomHighcutFilterChanged();
    break;
  case signalBand0SidechainLowcutFrequencyChanged:
    Q_EMIT band0SidechainLowcutFrequencyChanged();
    break;
  case signalBand1SidechainLowcutFrequencyChanged:
    Q_EMIT band1SidechainLowcutFrequencyChanged();
    break;
  case signalBand2SidechainLowcutFrequencyChanged:
    Q_EMIT band2SidechainLowcutFrequencyChanged();
    break;
  case signalBand3SidechainLowcutFrequencyChanged:
    Q_EMIT band3SidechainLowcutFrequencyChanged();
    break;
  case signalBand4SidechainLowcutFrequencyChanged:
    Q_EMIT band4SidechainLowcutFrequencyChanged();
    break;
  case signalBand5SidechainLowcutFrequencyChanged:
    Q_EMIT band5SidechainLowcutFrequencyChanged();
    break;
  case signalBand6SidechainLowcutFrequencyChanged:
    Q_EMIT band6SidechainLowcutFrequencyChanged();
    break;
  case signalBand7SidechainLowcutFrequencyChanged:
    Q_EMIT band7SidechainLowcutFrequencyChanged();
    break;
  case signalBand0SidechainHighcutFrequencyChanged:
    Q_EMIT band0SidechainHighcutFrequencyChanged();
    break;
  case signalBand1SidechainHighcutFrequencyChanged:
    Q_EMIT band1SidechainHighcutFrequencyChanged();
    break;
  case signalBand2SidechainHighcutFrequencyChanged:
    Q_EMIT band2SidechainHighcutFrequencyChanged();
    break;
  case signalBand3SidechainHighcutFrequencyChanged:
    Q_EMIT band3SidechainHighcutFrequencyChanged();
    break;
  case signalBand4SidechainHighcutFrequencyChanged:
    Q_EMIT band4SidechainHighcutFrequencyChanged();
    break;
  case signalBand5SidechainHighcutFrequencyChanged:
    Q_EMIT band5SidechainHighcutFrequencyChanged();
    break;
  case signalBand6SidechainHighcutFrequencyChanged:
    Q_EMIT band6SidechainHighcutFrequencyChanged();
    break;
  case signalBand7SidechainHighcutFrequencyChanged:
    Q_EMIT band7SidechainHighcutFrequencyChanged();
    break;
  case signalCompressionModeLabelsChanged:
    Q_EMIT compressionModeLabelsChanged();
    break;
  case signalBand0CompressionModeChanged:
    Q_EMIT band0CompressionModeChanged();
    break;
  case signalBand1CompressionModeChanged:
    Q_EMIT band1CompressionModeChanged();
    break;
  case signalBand2CompressionModeChanged:
    Q_EMIT band2CompressionModeChanged();
    break;
  case signalBand3CompressionModeChanged:
    Q_EMIT band3CompressionModeChanged();
    break;
  case signalBand4CompressionModeChanged:
    Q_EMIT band4CompressionModeChanged();
    break;
  case signalBand5CompressionModeChanged:
    Q_EMIT band5CompressionModeChanged();
    break;
  case signalBand6CompressionModeChanged:
    Q_EMIT band6CompressionModeChanged();
    break;
  case signalBand7CompressionModeChanged:
    Q_EMIT band7CompressionModeChanged();
    break;
  case signalBand0CompressorEnableChanged:
    Q_EMIT band0CompressorEnableChanged();
    break;
  case signalBand1CompressorEnableChanged:
    Q_EMIT band1CompressorEnableChanged();
    break;
  case signalBand2CompressorEnableChanged:
    Q_EMIT band2CompressorEnableChanged();
    break;
  case signalBand3CompressorEnableChanged:
    Q_EMIT band3CompressorEnableChanged();
    break;
  case signalBand4CompressorEnableChanged:
    Q_EMIT band4CompressorEnableChanged();
    break;
  case signalBand5CompressorEnableChanged:
    Q_EMIT band5CompressorEnableChanged();
    break;
  case signalBand6CompressorEnableChanged:
    Q_EMIT band6CompressorEnableChanged();
    break;
  case signalBand7CompressorEnableChanged:
    Q_EMIT band7CompressorEnableChanged();
    break;
  case signalBand0SoloChanged:
    Q_EMIT band0SoloChanged();
    break;
  case signalBand1SoloChanged:
    Q_EMIT band1SoloChanged();
    break;
  case signalBand2SoloChanged:
    Q_EMIT band2SoloChanged();
    break;
  case signalBand3SoloChanged:
    Q_EMIT band3SoloChanged();
    break;
  case signalBand4SoloChanged:
    Q_EMIT band4SoloChanged();
    break;
  case signalBand5SoloChanged:
    Q_EMIT band5SoloChanged();
    break;
  case signalBand6SoloChanged:
    Q_EMIT band6SoloChanged();
    break;
  case signalBand7SoloChanged:
    Q_EMIT band7SoloChanged();
    break;
  case signalBand0MuteChanged:
    Q_EMIT band0MuteChanged();
    break;
  case signalBand1MuteChanged:
    Q_EMIT band1MuteChanged();
    break;
  case signalBand2MuteChanged:
    Q_EMIT band2MuteChanged();
    break;
  case signalBand3MuteChanged:
    Q_EMIT band3MuteChanged();
    break;
  case signalBand4MuteChanged:
    Q_EMIT band4MuteChanged();
    break;
  case signalBand5MuteChanged:
    Q_EMIT band5MuteChanged();
    break;
  case signalBand6MuteChanged:
    Q_EMIT band6MuteChanged();
    break;
  case signalBand7MuteChanged:
    Q_EMIT band7MuteChanged();
    break;
  case signalBand0AttackThresholdChanged:
    Q_EMIT band0AttackThresholdChanged();
    break;
  case signalBand1AttackThresholdChanged:
    Q_EMIT band1AttackThresholdChanged();
    break;
  case signalBand2AttackThresholdChanged:
    Q_EMIT band2AttackThresholdChanged();
    break;
  case signalBand3AttackThresholdChanged:
    Q_EMIT band3AttackThresholdChanged();
    break;
  case signalBand4AttackThresholdChanged:
    Q_EMIT band4AttackThresholdChanged();
    break;
  case signalBand5AttackThresholdChanged:
    Q_EMIT band5AttackThresholdChanged();
    break;
  case signalBand6AttackThresholdChanged:
    Q_EMIT band6AttackThresholdChanged();
    break;
  case signalBand7AttackThresholdChanged:
    Q_EMIT band7AttackThresholdChanged();
    break;
  case signalBand0AttackTimeChanged:
    Q_EMIT band0AttackTimeChanged();
    break;
  case signalBand1AttackTimeChanged:
    Q_EMIT band1AttackTimeChanged();
    break;
  case signalBand2AttackTimeChanged:
    Q_EMIT band2AttackTimeChanged();
    break;
  case signalBand3AttackTimeChanged:
    Q_EMIT band3AttackTimeChanged();
    break;
  case signalBand4AttackTimeChanged:
    Q_EMIT band4AttackTimeChanged();
    break;
  case signalBand5AttackTimeChanged:
    Q_EMIT band5AttackTimeChanged();
    break;
  case signalBand6AttackTimeChanged:
    Q_EMIT band6AttackTimeChanged();
    break;
  case signalBand7AttackTimeChanged:
    Q_EMIT band7AttackTimeChanged();
    break;
  case signalBand0ReleaseThresholdChanged:
    Q_EMIT band0ReleaseThresholdChanged();
    break;
  case signalBand1ReleaseThresholdChanged:
    Q_EMIT band1ReleaseThresholdChanged();
    break;
  case signalBand2ReleaseThresholdChanged:
    Q_EMIT band2ReleaseThresholdChanged();
    break;
  case signalBand3ReleaseThresholdChanged:
    Q_EMIT band3ReleaseThresholdChanged();
    break;
  case signalBand4ReleaseThresholdChanged:
    Q_EMIT band4ReleaseThresholdChanged();
    break;
  case signalBand5ReleaseThresholdChanged:
    Q_EMIT band5ReleaseThresholdChanged();
    break;
  case signalBand6ReleaseThresholdChanged:
    Q_EMIT band6ReleaseThresholdChanged();
    break;
  case signalBand7ReleaseThresholdChanged:
    Q_EMIT band7ReleaseThresholdChanged();
    break;
  case signalBand0ReleaseTimeChanged:
    Q_EMIT band0ReleaseTimeChanged();
    break;
  case signalBand1ReleaseTimeChanged:
    Q_EMIT band1ReleaseTimeChanged();
    break;
  case signalBand2ReleaseTimeChanged:
    Q_EMIT band2ReleaseTimeChanged();
    break;
  case signalBand3ReleaseTimeChanged:
    Q_EMIT band3ReleaseTimeChanged();
    break;
  case signalBand4ReleaseTimeChanged:
    Q_EMIT band4ReleaseTimeChanged();
    break;
  case signalBand5ReleaseTimeChanged:
    Q_EMIT band5ReleaseTimeChanged();
    break;
  case signalBand6ReleaseTimeChanged:
    Q_EMIT band6ReleaseTimeChanged();
    break;
  case signalBand7ReleaseTimeChanged:
    Q_EMIT band7ReleaseTimeChanged();
    break;
  case signalBand0RatioChanged:
    Q_EMIT band0RatioChanged();
    break;
  case signalBand1RatioChanged:
    Q_EMIT band1RatioChanged();
    break;
  case signalBand2RatioChanged:
    Q_EMIT band2RatioChanged();
    break;
  case signalBand3RatioChanged:
    Q_EMIT band3RatioChanged();
    break;
  case signalBand4RatioChanged:
    Q_EMIT band4RatioChanged();
    break;
  case signalBand5RatioChanged:
    Q_EMIT band5RatioChanged();
    break;
  case signalBand6RatioChanged:
    Q_EMIT band6RatioChanged();
    break;
  case signalBand7RatioChanged:
    Q_EMIT band7RatioChanged();
    break;
  case signalBand0KneeChanged:
    Q_EMIT band0KneeChanged();
    break;
  case signalBand1KneeChanged:
    Q_EMIT band1KneeChanged();
    break;
  case signalBand2KneeChanged:
    Q_EMIT band2KneeChanged();
    break;
  case signalBand3KneeChanged:
    Q_EMIT band3KneeChanged();
    break;
  case signalBand4KneeChanged:
    Q_EMIT band4KneeChanged();
    break;
  case signalBand5KneeChanged:
    Q_EMIT band5KneeChanged();
    break;
  case signalBand6KneeChanged:
    Q_EMIT band6KneeChanged();
    break;
  case signalBand7KneeChanged:
    Q_EMIT band7KneeChanged();
    break;
  case signalBand0BoostThresholdChanged:
    Q_EMIT band0BoostThresholdChanged();
    break;
  case signalBand1BoostThresholdChanged:
    Q_EMIT band1BoostThresholdChanged();
    break;
  case signalBand2BoostThresholdChanged:
    Q_EMIT band2BoostThresholdChanged();
    break;
  case signalBand3BoostThresholdChanged:
    Q_EMIT band3BoostThresholdChanged();
    break;
  case signalBand4BoostThresholdChanged:
    Q_EMIT band4BoostThresholdChanged();
    break;
  case signalBand5BoostThresholdChanged:
    Q_EMIT band5BoostThresholdChanged();
    break;
  case signalBand6BoostThresholdChanged:
    Q_EMIT band6BoostThresholdChanged();
    break;
  case signalBand7BoostThresholdChanged:
    Q_EMIT band7BoostThresholdChanged();
    break;
  case signalBand0BoostAmountChanged:
    Q_EMIT band0BoostAmountChanged();
    break;
  case signalBand1BoostAmountChanged:
    Q_EMIT band1BoostAmountChanged();
    break;
  case signalBand2BoostAmountChanged:
    Q_EMIT band2BoostAmountChanged();
    break;
  case signalBand3BoostAmountChanged:
    Q_EMIT band3BoostAmountChanged();
    break;
  case signalBand4BoostAmountChanged:
    Q_EMIT band4BoostAmountChanged();
    break;
  case signalBand5BoostAmountChanged:
    Q_EMIT band5BoostAmountChanged();
    break;
  case signalBand6BoostAmountChanged:
    Q_EMIT band6BoostAmountChanged();
    break;
  case signalBand7BoostAmountChanged:
    Q_EMIT band7BoostAmountChanged();
    break;
  case signalBand0MakeupChanged:
    Q_EMIT band0MakeupChanged();
    break;
  case signalBand1MakeupChanged:
    Q_EMIT band1MakeupChanged();
    break;
  case signalBand2MakeupChanged:
    Q_EMIT band2MakeupChanged();
    break;
  case signalBand3MakeupChanged:
    Q_EMIT band3MakeupChanged();
    break;
  case signalBand4MakeupChanged:
    Q_EMIT band4MakeupChanged();
    break;
  case signalBand5MakeupChanged:
    Q_EMIT band5MakeupChanged();
    break;
  case signalBand6MakeupChanged:
    Q_EMIT band6MakeupChanged();
    break;
  case signalBand7MakeupChanged:
    Q_EMIT band7MakeupChanged();
    break;
  }
}
