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

#include "easyeffects_db_multiband_gate.h"

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

  KConfigGroup cgmasterGroup(this->config(), QStringLiteral( "%1" ).arg( mParammasterGroup ));
  KConfigGroup cgMultibandGateinstanceIndex = cgmasterGroup.group(QStringLiteral( "MultibandGate#%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(cgMultibandGateinstanceIndex);
  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(cgMultibandGateinstanceIndex);
  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(cgMultibandGateinstanceIndex);
  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(cgMultibandGateinstanceIndex);
  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(cgMultibandGateinstanceIndex);
  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(cgMultibandGateinstanceIndex);
  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(cgMultibandGateinstanceIndex);
  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(cgMultibandGateinstanceIndex);
  addItem( itemStereoSplit, QStringLiteral( "stereoSplit" ) );
  QStringList defaultgateModeLabels;
  defaultgateModeLabels.append( QString::fromUtf8( "Classic" ) );
  defaultgateModeLabels.append( QString::fromUtf8( "Modern" ) );
  defaultgateModeLabels.append( QString::fromUtf8( "Linear Phase" ) );

  KConfigCompilerSignallingItem  *itemGateModeLabels;
  KConfigBaseEE::ItemStringList  *innerItemGateModeLabels;
  innerItemGateModeLabels = new KConfigBaseEE::ItemStringList( currentGroup(), QStringLiteral( "gateModeLabels" ), mGateModeLabels, defaultgateModeLabels );
  itemGateModeLabels = new KConfigCompilerSignallingItem(innerItemGateModeLabels, this, notifyFunction, signalGateModeLabelsChanged);
  itemGateModeLabels->setWriteFlags(KConfigBase::Notify);
  itemGateModeLabels->setGroup(cgMultibandGateinstanceIndex);
  addItem( itemGateModeLabels, QStringLiteral( "gateModeLabels" ) );
  KConfigCompilerSignallingItem  *itemGateMode;
  KConfigBaseEE::ItemInt  *innerItemGateMode;
  innerItemGateMode = new KConfigBaseEE::ItemInt( currentGroup(), QStringLiteral( "gateMode" ), mGateMode, 1 );
  itemGateMode = new KConfigCompilerSignallingItem(innerItemGateMode, this, notifyFunction, signalGateModeChanged);
  itemGateMode->setWriteFlags(KConfigBase::Notify);
  itemGateMode->setGroup(cgMultibandGateinstanceIndex);
  addItem( itemGateMode, QStringLiteral( "gateMode" ) );
  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(cgMultibandGateinstanceIndex);
  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(cgMultibandGateinstanceIndex);
  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(cgMultibandGateinstanceIndex);
  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(cgMultibandGateinstanceIndex);
  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(cgMultibandGateinstanceIndex);
  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(cgMultibandGateinstanceIndex);
  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(cgMultibandGateinstanceIndex);
  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(cgMultibandGateinstanceIndex);
  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(cgMultibandGateinstanceIndex);
  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(cgMultibandGateinstanceIndex);
  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(cgMultibandGateinstanceIndex);
  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(cgMultibandGateinstanceIndex);
  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(cgMultibandGateinstanceIndex);
  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(cgMultibandGateinstanceIndex);
  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(cgMultibandGateinstanceIndex);
  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(cgMultibandGateinstanceIndex);
  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(cgMultibandGateinstanceIndex);
  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(cgMultibandGateinstanceIndex);
  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(cgMultibandGateinstanceIndex);
  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(cgMultibandGateinstanceIndex);
  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(cgMultibandGateinstanceIndex);
  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(cgMultibandGateinstanceIndex);
  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(cgMultibandGateinstanceIndex);
  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(cgMultibandGateinstanceIndex);
  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(cgMultibandGateinstanceIndex);
  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(cgMultibandGateinstanceIndex);
  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(cgMultibandGateinstanceIndex);
  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(cgMultibandGateinstanceIndex);
  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(cgMultibandGateinstanceIndex);
  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(cgMultibandGateinstanceIndex);
  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(cgMultibandGateinstanceIndex);
  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(cgMultibandGateinstanceIndex);
  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(cgMultibandGateinstanceIndex);
  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(cgMultibandGateinstanceIndex);
  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(cgMultibandGateinstanceIndex);
  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(cgMultibandGateinstanceIndex);
  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(cgMultibandGateinstanceIndex);
  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(cgMultibandGateinstanceIndex);
  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(cgMultibandGateinstanceIndex);
  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(cgMultibandGateinstanceIndex);
  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(cgMultibandGateinstanceIndex);
  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(cgMultibandGateinstanceIndex);
  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(cgMultibandGateinstanceIndex);
  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(cgMultibandGateinstanceIndex);
  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(cgMultibandGateinstanceIndex);
  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(cgMultibandGateinstanceIndex);
  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(cgMultibandGateinstanceIndex);
  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(cgMultibandGateinstanceIndex);
  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(cgMultibandGateinstanceIndex);
  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(cgMultibandGateinstanceIndex);
  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(cgMultibandGateinstanceIndex);
  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(cgMultibandGateinstanceIndex);
  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(cgMultibandGateinstanceIndex);
  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(cgMultibandGateinstanceIndex);
  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(cgMultibandGateinstanceIndex);
  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(cgMultibandGateinstanceIndex);
  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(cgMultibandGateinstanceIndex);
  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(cgMultibandGateinstanceIndex);
  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(cgMultibandGateinstanceIndex);
  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(cgMultibandGateinstanceIndex);
  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(cgMultibandGateinstanceIndex);
  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(cgMultibandGateinstanceIndex);
  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(cgMultibandGateinstanceIndex);
  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(cgMultibandGateinstanceIndex);
  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(cgMultibandGateinstanceIndex);
  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(cgMultibandGateinstanceIndex);
  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(cgMultibandGateinstanceIndex);
  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(cgMultibandGateinstanceIndex);
  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(cgMultibandGateinstanceIndex);
  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(cgMultibandGateinstanceIndex);
  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(cgMultibandGateinstanceIndex);
  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(cgMultibandGateinstanceIndex);
  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(cgMultibandGateinstanceIndex);
  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(cgMultibandGateinstanceIndex);
  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(cgMultibandGateinstanceIndex);
  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(cgMultibandGateinstanceIndex);
  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(cgMultibandGateinstanceIndex);
  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(cgMultibandGateinstanceIndex);
  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(cgMultibandGateinstanceIndex);
  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(cgMultibandGateinstanceIndex);
  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(cgMultibandGateinstanceIndex);
  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(cgMultibandGateinstanceIndex);
  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(cgMultibandGateinstanceIndex);
  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(cgMultibandGateinstanceIndex);
  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(cgMultibandGateinstanceIndex);
  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(cgMultibandGateinstanceIndex);
  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(cgMultibandGateinstanceIndex);
  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(cgMultibandGateinstanceIndex);
  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(cgMultibandGateinstanceIndex);
  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(cgMultibandGateinstanceIndex);
  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(cgMultibandGateinstanceIndex);
  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(cgMultibandGateinstanceIndex);
  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(cgMultibandGateinstanceIndex);
  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(cgMultibandGateinstanceIndex);
  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(cgMultibandGateinstanceIndex);
  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(cgMultibandGateinstanceIndex);
  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(cgMultibandGateinstanceIndex);
  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(cgMultibandGateinstanceIndex);
  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(cgMultibandGateinstanceIndex);
  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(cgMultibandGateinstanceIndex);
  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(cgMultibandGateinstanceIndex);
  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(cgMultibandGateinstanceIndex);
  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(cgMultibandGateinstanceIndex);
  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(cgMultibandGateinstanceIndex);
  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(cgMultibandGateinstanceIndex);
  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(cgMultibandGateinstanceIndex);
  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(cgMultibandGateinstanceIndex);
  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(cgMultibandGateinstanceIndex);
  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(cgMultibandGateinstanceIndex);
  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(cgMultibandGateinstanceIndex);
  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(cgMultibandGateinstanceIndex);
  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(cgMultibandGateinstanceIndex);
  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(cgMultibandGateinstanceIndex);
  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(cgMultibandGateinstanceIndex);
  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(cgMultibandGateinstanceIndex);
  addItem( itemBand7SidechainHighcutFrequency, QStringLiteral( "band7SidechainHighcutFrequency" ) );
  KConfigCompilerSignallingItem  *itemBand0GateEnable;
  KConfigBaseEE::ItemBool  *innerItemBand0GateEnable;
  innerItemBand0GateEnable = new KConfigBaseEE::ItemBool( currentGroup(), QStringLiteral( "band0GateEnable" ), mBand0GateEnable, true );
  itemBand0GateEnable = new KConfigCompilerSignallingItem(innerItemBand0GateEnable, this, notifyFunction, signalBand0GateEnableChanged);
  itemBand0GateEnable->setWriteFlags(KConfigBase::Notify);
  itemBand0GateEnable->setGroup(cgMultibandGateinstanceIndex);
  addItem( itemBand0GateEnable, QStringLiteral( "band0GateEnable" ) );
  KConfigCompilerSignallingItem  *itemBand1GateEnable;
  KConfigBaseEE::ItemBool  *innerItemBand1GateEnable;
  innerItemBand1GateEnable = new KConfigBaseEE::ItemBool( currentGroup(), QStringLiteral( "band1GateEnable" ), mBand1GateEnable, true );
  itemBand1GateEnable = new KConfigCompilerSignallingItem(innerItemBand1GateEnable, this, notifyFunction, signalBand1GateEnableChanged);
  itemBand1GateEnable->setWriteFlags(KConfigBase::Notify);
  itemBand1GateEnable->setGroup(cgMultibandGateinstanceIndex);
  addItem( itemBand1GateEnable, QStringLiteral( "band1GateEnable" ) );
  KConfigCompilerSignallingItem  *itemBand2GateEnable;
  KConfigBaseEE::ItemBool  *innerItemBand2GateEnable;
  innerItemBand2GateEnable = new KConfigBaseEE::ItemBool( currentGroup(), QStringLiteral( "band2GateEnable" ), mBand2GateEnable, true );
  itemBand2GateEnable = new KConfigCompilerSignallingItem(innerItemBand2GateEnable, this, notifyFunction, signalBand2GateEnableChanged);
  itemBand2GateEnable->setWriteFlags(KConfigBase::Notify);
  itemBand2GateEnable->setGroup(cgMultibandGateinstanceIndex);
  addItem( itemBand2GateEnable, QStringLiteral( "band2GateEnable" ) );
  KConfigCompilerSignallingItem  *itemBand3GateEnable;
  KConfigBaseEE::ItemBool  *innerItemBand3GateEnable;
  innerItemBand3GateEnable = new KConfigBaseEE::ItemBool( currentGroup(), QStringLiteral( "band3GateEnable" ), mBand3GateEnable, true );
  itemBand3GateEnable = new KConfigCompilerSignallingItem(innerItemBand3GateEnable, this, notifyFunction, signalBand3GateEnableChanged);
  itemBand3GateEnable->setWriteFlags(KConfigBase::Notify);
  itemBand3GateEnable->setGroup(cgMultibandGateinstanceIndex);
  addItem( itemBand3GateEnable, QStringLiteral( "band3GateEnable" ) );
  KConfigCompilerSignallingItem  *itemBand4GateEnable;
  KConfigBaseEE::ItemBool  *innerItemBand4GateEnable;
  innerItemBand4GateEnable = new KConfigBaseEE::ItemBool( currentGroup(), QStringLiteral( "band4GateEnable" ), mBand4GateEnable, true );
  itemBand4GateEnable = new KConfigCompilerSignallingItem(innerItemBand4GateEnable, this, notifyFunction, signalBand4GateEnableChanged);
  itemBand4GateEnable->setWriteFlags(KConfigBase::Notify);
  itemBand4GateEnable->setGroup(cgMultibandGateinstanceIndex);
  addItem( itemBand4GateEnable, QStringLiteral( "band4GateEnable" ) );
  KConfigCompilerSignallingItem  *itemBand5GateEnable;
  KConfigBaseEE::ItemBool  *innerItemBand5GateEnable;
  innerItemBand5GateEnable = new KConfigBaseEE::ItemBool( currentGroup(), QStringLiteral( "band5GateEnable" ), mBand5GateEnable, true );
  itemBand5GateEnable = new KConfigCompilerSignallingItem(innerItemBand5GateEnable, this, notifyFunction, signalBand5GateEnableChanged);
  itemBand5GateEnable->setWriteFlags(KConfigBase::Notify);
  itemBand5GateEnable->setGroup(cgMultibandGateinstanceIndex);
  addItem( itemBand5GateEnable, QStringLiteral( "band5GateEnable" ) );
  KConfigCompilerSignallingItem  *itemBand6GateEnable;
  KConfigBaseEE::ItemBool  *innerItemBand6GateEnable;
  innerItemBand6GateEnable = new KConfigBaseEE::ItemBool( currentGroup(), QStringLiteral( "band6GateEnable" ), mBand6GateEnable, true );
  itemBand6GateEnable = new KConfigCompilerSignallingItem(innerItemBand6GateEnable, this, notifyFunction, signalBand6GateEnableChanged);
  itemBand6GateEnable->setWriteFlags(KConfigBase::Notify);
  itemBand6GateEnable->setGroup(cgMultibandGateinstanceIndex);
  addItem( itemBand6GateEnable, QStringLiteral( "band6GateEnable" ) );
  KConfigCompilerSignallingItem  *itemBand7GateEnable;
  KConfigBaseEE::ItemBool  *innerItemBand7GateEnable;
  innerItemBand7GateEnable = new KConfigBaseEE::ItemBool( currentGroup(), QStringLiteral( "band7GateEnable" ), mBand7GateEnable, true );
  itemBand7GateEnable = new KConfigCompilerSignallingItem(innerItemBand7GateEnable, this, notifyFunction, signalBand7GateEnableChanged);
  itemBand7GateEnable->setWriteFlags(KConfigBase::Notify);
  itemBand7GateEnable->setGroup(cgMultibandGateinstanceIndex);
  addItem( itemBand7GateEnable, QStringLiteral( "band7GateEnable" ) );
  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(cgMultibandGateinstanceIndex);
  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(cgMultibandGateinstanceIndex);
  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(cgMultibandGateinstanceIndex);
  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(cgMultibandGateinstanceIndex);
  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(cgMultibandGateinstanceIndex);
  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(cgMultibandGateinstanceIndex);
  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(cgMultibandGateinstanceIndex);
  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(cgMultibandGateinstanceIndex);
  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(cgMultibandGateinstanceIndex);
  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(cgMultibandGateinstanceIndex);
  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(cgMultibandGateinstanceIndex);
  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(cgMultibandGateinstanceIndex);
  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(cgMultibandGateinstanceIndex);
  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(cgMultibandGateinstanceIndex);
  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(cgMultibandGateinstanceIndex);
  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(cgMultibandGateinstanceIndex);
  addItem( itemBand7Mute, QStringLiteral( "band7Mute" ) );
  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(cgMultibandGateinstanceIndex);
  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(cgMultibandGateinstanceIndex);
  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(cgMultibandGateinstanceIndex);
  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(cgMultibandGateinstanceIndex);
  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(cgMultibandGateinstanceIndex);
  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(cgMultibandGateinstanceIndex);
  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(cgMultibandGateinstanceIndex);
  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(cgMultibandGateinstanceIndex);
  addItem( itemBand7AttackTime, QStringLiteral( "band7AttackTime" ) );
  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(cgMultibandGateinstanceIndex);
  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(cgMultibandGateinstanceIndex);
  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(cgMultibandGateinstanceIndex);
  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(cgMultibandGateinstanceIndex);
  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(cgMultibandGateinstanceIndex);
  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(cgMultibandGateinstanceIndex);
  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(cgMultibandGateinstanceIndex);
  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(cgMultibandGateinstanceIndex);
  addItem( itemBand7ReleaseTime, QStringLiteral( "band7ReleaseTime" ) );
  KConfigCompilerSignallingItem  *itemBand0Hysteresis;
  KConfigBaseEE::ItemBool  *innerItemBand0Hysteresis;
  innerItemBand0Hysteresis = new KConfigBaseEE::ItemBool( currentGroup(), QStringLiteral( "band0Hysteresis" ), mBand0Hysteresis, false );
  itemBand0Hysteresis = new KConfigCompilerSignallingItem(innerItemBand0Hysteresis, this, notifyFunction, signalBand0HysteresisChanged);
  itemBand0Hysteresis->setWriteFlags(KConfigBase::Notify);
  itemBand0Hysteresis->setGroup(cgMultibandGateinstanceIndex);
  addItem( itemBand0Hysteresis, QStringLiteral( "band0Hysteresis" ) );
  KConfigCompilerSignallingItem  *itemBand1Hysteresis;
  KConfigBaseEE::ItemBool  *innerItemBand1Hysteresis;
  innerItemBand1Hysteresis = new KConfigBaseEE::ItemBool( currentGroup(), QStringLiteral( "band1Hysteresis" ), mBand1Hysteresis, false );
  itemBand1Hysteresis = new KConfigCompilerSignallingItem(innerItemBand1Hysteresis, this, notifyFunction, signalBand1HysteresisChanged);
  itemBand1Hysteresis->setWriteFlags(KConfigBase::Notify);
  itemBand1Hysteresis->setGroup(cgMultibandGateinstanceIndex);
  addItem( itemBand1Hysteresis, QStringLiteral( "band1Hysteresis" ) );
  KConfigCompilerSignallingItem  *itemBand2Hysteresis;
  KConfigBaseEE::ItemBool  *innerItemBand2Hysteresis;
  innerItemBand2Hysteresis = new KConfigBaseEE::ItemBool( currentGroup(), QStringLiteral( "band2Hysteresis" ), mBand2Hysteresis, false );
  itemBand2Hysteresis = new KConfigCompilerSignallingItem(innerItemBand2Hysteresis, this, notifyFunction, signalBand2HysteresisChanged);
  itemBand2Hysteresis->setWriteFlags(KConfigBase::Notify);
  itemBand2Hysteresis->setGroup(cgMultibandGateinstanceIndex);
  addItem( itemBand2Hysteresis, QStringLiteral( "band2Hysteresis" ) );
  KConfigCompilerSignallingItem  *itemBand3Hysteresis;
  KConfigBaseEE::ItemBool  *innerItemBand3Hysteresis;
  innerItemBand3Hysteresis = new KConfigBaseEE::ItemBool( currentGroup(), QStringLiteral( "band3Hysteresis" ), mBand3Hysteresis, false );
  itemBand3Hysteresis = new KConfigCompilerSignallingItem(innerItemBand3Hysteresis, this, notifyFunction, signalBand3HysteresisChanged);
  itemBand3Hysteresis->setWriteFlags(KConfigBase::Notify);
  itemBand3Hysteresis->setGroup(cgMultibandGateinstanceIndex);
  addItem( itemBand3Hysteresis, QStringLiteral( "band3Hysteresis" ) );
  KConfigCompilerSignallingItem  *itemBand4Hysteresis;
  KConfigBaseEE::ItemBool  *innerItemBand4Hysteresis;
  innerItemBand4Hysteresis = new KConfigBaseEE::ItemBool( currentGroup(), QStringLiteral( "band4Hysteresis" ), mBand4Hysteresis, false );
  itemBand4Hysteresis = new KConfigCompilerSignallingItem(innerItemBand4Hysteresis, this, notifyFunction, signalBand4HysteresisChanged);
  itemBand4Hysteresis->setWriteFlags(KConfigBase::Notify);
  itemBand4Hysteresis->setGroup(cgMultibandGateinstanceIndex);
  addItem( itemBand4Hysteresis, QStringLiteral( "band4Hysteresis" ) );
  KConfigCompilerSignallingItem  *itemBand5Hysteresis;
  KConfigBaseEE::ItemBool  *innerItemBand5Hysteresis;
  innerItemBand5Hysteresis = new KConfigBaseEE::ItemBool( currentGroup(), QStringLiteral( "band5Hysteresis" ), mBand5Hysteresis, false );
  itemBand5Hysteresis = new KConfigCompilerSignallingItem(innerItemBand5Hysteresis, this, notifyFunction, signalBand5HysteresisChanged);
  itemBand5Hysteresis->setWriteFlags(KConfigBase::Notify);
  itemBand5Hysteresis->setGroup(cgMultibandGateinstanceIndex);
  addItem( itemBand5Hysteresis, QStringLiteral( "band5Hysteresis" ) );
  KConfigCompilerSignallingItem  *itemBand6Hysteresis;
  KConfigBaseEE::ItemBool  *innerItemBand6Hysteresis;
  innerItemBand6Hysteresis = new KConfigBaseEE::ItemBool( currentGroup(), QStringLiteral( "band6Hysteresis" ), mBand6Hysteresis, false );
  itemBand6Hysteresis = new KConfigCompilerSignallingItem(innerItemBand6Hysteresis, this, notifyFunction, signalBand6HysteresisChanged);
  itemBand6Hysteresis->setWriteFlags(KConfigBase::Notify);
  itemBand6Hysteresis->setGroup(cgMultibandGateinstanceIndex);
  addItem( itemBand6Hysteresis, QStringLiteral( "band6Hysteresis" ) );
  KConfigCompilerSignallingItem  *itemBand7Hysteresis;
  KConfigBaseEE::ItemBool  *innerItemBand7Hysteresis;
  innerItemBand7Hysteresis = new KConfigBaseEE::ItemBool( currentGroup(), QStringLiteral( "band7Hysteresis" ), mBand7Hysteresis, false );
  itemBand7Hysteresis = new KConfigCompilerSignallingItem(innerItemBand7Hysteresis, this, notifyFunction, signalBand7HysteresisChanged);
  itemBand7Hysteresis->setWriteFlags(KConfigBase::Notify);
  itemBand7Hysteresis->setGroup(cgMultibandGateinstanceIndex);
  addItem( itemBand7Hysteresis, QStringLiteral( "band7Hysteresis" ) );
  KConfigCompilerSignallingItem  *itemBand0HysteresisThreshold;
  KConfigBaseEE::ItemDouble  *innerItemBand0HysteresisThreshold;
  innerItemBand0HysteresisThreshold = new KConfigBaseEE::ItemDouble( currentGroup(), QStringLiteral( "band0HysteresisThreshold" ), mBand0HysteresisThreshold, -12 );
  itemBand0HysteresisThreshold = new KConfigCompilerSignallingItem(innerItemBand0HysteresisThreshold, this, notifyFunction, signalBand0HysteresisThresholdChanged);
  innerItemBand0HysteresisThreshold->setMinValue(-60);
  innerItemBand0HysteresisThreshold->setMaxValue(0);
  itemBand0HysteresisThreshold->setWriteFlags(KConfigBase::Notify);
  itemBand0HysteresisThreshold->setGroup(cgMultibandGateinstanceIndex);
  addItem( itemBand0HysteresisThreshold, QStringLiteral( "band0HysteresisThreshold" ) );
  KConfigCompilerSignallingItem  *itemBand1HysteresisThreshold;
  KConfigBaseEE::ItemDouble  *innerItemBand1HysteresisThreshold;
  innerItemBand1HysteresisThreshold = new KConfigBaseEE::ItemDouble( currentGroup(), QStringLiteral( "band1HysteresisThreshold" ), mBand1HysteresisThreshold, -12 );
  itemBand1HysteresisThreshold = new KConfigCompilerSignallingItem(innerItemBand1HysteresisThreshold, this, notifyFunction, signalBand1HysteresisThresholdChanged);
  innerItemBand1HysteresisThreshold->setMinValue(-60);
  innerItemBand1HysteresisThreshold->setMaxValue(0);
  itemBand1HysteresisThreshold->setWriteFlags(KConfigBase::Notify);
  itemBand1HysteresisThreshold->setGroup(cgMultibandGateinstanceIndex);
  addItem( itemBand1HysteresisThreshold, QStringLiteral( "band1HysteresisThreshold" ) );
  KConfigCompilerSignallingItem  *itemBand2HysteresisThreshold;
  KConfigBaseEE::ItemDouble  *innerItemBand2HysteresisThreshold;
  innerItemBand2HysteresisThreshold = new KConfigBaseEE::ItemDouble( currentGroup(), QStringLiteral( "band2HysteresisThreshold" ), mBand2HysteresisThreshold, -12 );
  itemBand2HysteresisThreshold = new KConfigCompilerSignallingItem(innerItemBand2HysteresisThreshold, this, notifyFunction, signalBand2HysteresisThresholdChanged);
  innerItemBand2HysteresisThreshold->setMinValue(-60);
  innerItemBand2HysteresisThreshold->setMaxValue(0);
  itemBand2HysteresisThreshold->setWriteFlags(KConfigBase::Notify);
  itemBand2HysteresisThreshold->setGroup(cgMultibandGateinstanceIndex);
  addItem( itemBand2HysteresisThreshold, QStringLiteral( "band2HysteresisThreshold" ) );
  KConfigCompilerSignallingItem  *itemBand3HysteresisThreshold;
  KConfigBaseEE::ItemDouble  *innerItemBand3HysteresisThreshold;
  innerItemBand3HysteresisThreshold = new KConfigBaseEE::ItemDouble( currentGroup(), QStringLiteral( "band3HysteresisThreshold" ), mBand3HysteresisThreshold, -12 );
  itemBand3HysteresisThreshold = new KConfigCompilerSignallingItem(innerItemBand3HysteresisThreshold, this, notifyFunction, signalBand3HysteresisThresholdChanged);
  innerItemBand3HysteresisThreshold->setMinValue(-60);
  innerItemBand3HysteresisThreshold->setMaxValue(0);
  itemBand3HysteresisThreshold->setWriteFlags(KConfigBase::Notify);
  itemBand3HysteresisThreshold->setGroup(cgMultibandGateinstanceIndex);
  addItem( itemBand3HysteresisThreshold, QStringLiteral( "band3HysteresisThreshold" ) );
  KConfigCompilerSignallingItem  *itemBand4HysteresisThreshold;
  KConfigBaseEE::ItemDouble  *innerItemBand4HysteresisThreshold;
  innerItemBand4HysteresisThreshold = new KConfigBaseEE::ItemDouble( currentGroup(), QStringLiteral( "band4HysteresisThreshold" ), mBand4HysteresisThreshold, -12 );
  itemBand4HysteresisThreshold = new KConfigCompilerSignallingItem(innerItemBand4HysteresisThreshold, this, notifyFunction, signalBand4HysteresisThresholdChanged);
  innerItemBand4HysteresisThreshold->setMinValue(-60);
  innerItemBand4HysteresisThreshold->setMaxValue(0);
  itemBand4HysteresisThreshold->setWriteFlags(KConfigBase::Notify);
  itemBand4HysteresisThreshold->setGroup(cgMultibandGateinstanceIndex);
  addItem( itemBand4HysteresisThreshold, QStringLiteral( "band4HysteresisThreshold" ) );
  KConfigCompilerSignallingItem  *itemBand5HysteresisThreshold;
  KConfigBaseEE::ItemDouble  *innerItemBand5HysteresisThreshold;
  innerItemBand5HysteresisThreshold = new KConfigBaseEE::ItemDouble( currentGroup(), QStringLiteral( "band5HysteresisThreshold" ), mBand5HysteresisThreshold, -12 );
  itemBand5HysteresisThreshold = new KConfigCompilerSignallingItem(innerItemBand5HysteresisThreshold, this, notifyFunction, signalBand5HysteresisThresholdChanged);
  innerItemBand5HysteresisThreshold->setMinValue(-60);
  innerItemBand5HysteresisThreshold->setMaxValue(0);
  itemBand5HysteresisThreshold->setWriteFlags(KConfigBase::Notify);
  itemBand5HysteresisThreshold->setGroup(cgMultibandGateinstanceIndex);
  addItem( itemBand5HysteresisThreshold, QStringLiteral( "band5HysteresisThreshold" ) );
  KConfigCompilerSignallingItem  *itemBand6HysteresisThreshold;
  KConfigBaseEE::ItemDouble  *innerItemBand6HysteresisThreshold;
  innerItemBand6HysteresisThreshold = new KConfigBaseEE::ItemDouble( currentGroup(), QStringLiteral( "band6HysteresisThreshold" ), mBand6HysteresisThreshold, -12 );
  itemBand6HysteresisThreshold = new KConfigCompilerSignallingItem(innerItemBand6HysteresisThreshold, this, notifyFunction, signalBand6HysteresisThresholdChanged);
  innerItemBand6HysteresisThreshold->setMinValue(-60);
  innerItemBand6HysteresisThreshold->setMaxValue(0);
  itemBand6HysteresisThreshold->setWriteFlags(KConfigBase::Notify);
  itemBand6HysteresisThreshold->setGroup(cgMultibandGateinstanceIndex);
  addItem( itemBand6HysteresisThreshold, QStringLiteral( "band6HysteresisThreshold" ) );
  KConfigCompilerSignallingItem  *itemBand7HysteresisThreshold;
  KConfigBaseEE::ItemDouble  *innerItemBand7HysteresisThreshold;
  innerItemBand7HysteresisThreshold = new KConfigBaseEE::ItemDouble( currentGroup(), QStringLiteral( "band7HysteresisThreshold" ), mBand7HysteresisThreshold, -12 );
  itemBand7HysteresisThreshold = new KConfigCompilerSignallingItem(innerItemBand7HysteresisThreshold, this, notifyFunction, signalBand7HysteresisThresholdChanged);
  innerItemBand7HysteresisThreshold->setMinValue(-60);
  innerItemBand7HysteresisThreshold->setMaxValue(0);
  itemBand7HysteresisThreshold->setWriteFlags(KConfigBase::Notify);
  itemBand7HysteresisThreshold->setGroup(cgMultibandGateinstanceIndex);
  addItem( itemBand7HysteresisThreshold, QStringLiteral( "band7HysteresisThreshold" ) );
  KConfigCompilerSignallingItem  *itemBand0HysteresisZone;
  KConfigBaseEE::ItemDouble  *innerItemBand0HysteresisZone;
  innerItemBand0HysteresisZone = new KConfigBaseEE::ItemDouble( currentGroup(), QStringLiteral( "band0HysteresisZone" ), mBand0HysteresisZone, -6 );
  itemBand0HysteresisZone = new KConfigCompilerSignallingItem(innerItemBand0HysteresisZone, this, notifyFunction, signalBand0HysteresisZoneChanged);
  innerItemBand0HysteresisZone->setMinValue(-60);
  innerItemBand0HysteresisZone->setMaxValue(0);
  itemBand0HysteresisZone->setWriteFlags(KConfigBase::Notify);
  itemBand0HysteresisZone->setGroup(cgMultibandGateinstanceIndex);
  addItem( itemBand0HysteresisZone, QStringLiteral( "band0HysteresisZone" ) );
  KConfigCompilerSignallingItem  *itemBand1HysteresisZone;
  KConfigBaseEE::ItemDouble  *innerItemBand1HysteresisZone;
  innerItemBand1HysteresisZone = new KConfigBaseEE::ItemDouble( currentGroup(), QStringLiteral( "band1HysteresisZone" ), mBand1HysteresisZone, -6 );
  itemBand1HysteresisZone = new KConfigCompilerSignallingItem(innerItemBand1HysteresisZone, this, notifyFunction, signalBand1HysteresisZoneChanged);
  innerItemBand1HysteresisZone->setMinValue(-60);
  innerItemBand1HysteresisZone->setMaxValue(0);
  itemBand1HysteresisZone->setWriteFlags(KConfigBase::Notify);
  itemBand1HysteresisZone->setGroup(cgMultibandGateinstanceIndex);
  addItem( itemBand1HysteresisZone, QStringLiteral( "band1HysteresisZone" ) );
  KConfigCompilerSignallingItem  *itemBand2HysteresisZone;
  KConfigBaseEE::ItemDouble  *innerItemBand2HysteresisZone;
  innerItemBand2HysteresisZone = new KConfigBaseEE::ItemDouble( currentGroup(), QStringLiteral( "band2HysteresisZone" ), mBand2HysteresisZone, -6 );
  itemBand2HysteresisZone = new KConfigCompilerSignallingItem(innerItemBand2HysteresisZone, this, notifyFunction, signalBand2HysteresisZoneChanged);
  innerItemBand2HysteresisZone->setMinValue(-60);
  innerItemBand2HysteresisZone->setMaxValue(0);
  itemBand2HysteresisZone->setWriteFlags(KConfigBase::Notify);
  itemBand2HysteresisZone->setGroup(cgMultibandGateinstanceIndex);
  addItem( itemBand2HysteresisZone, QStringLiteral( "band2HysteresisZone" ) );
  KConfigCompilerSignallingItem  *itemBand3HysteresisZone;
  KConfigBaseEE::ItemDouble  *innerItemBand3HysteresisZone;
  innerItemBand3HysteresisZone = new KConfigBaseEE::ItemDouble( currentGroup(), QStringLiteral( "band3HysteresisZone" ), mBand3HysteresisZone, -6 );
  itemBand3HysteresisZone = new KConfigCompilerSignallingItem(innerItemBand3HysteresisZone, this, notifyFunction, signalBand3HysteresisZoneChanged);
  innerItemBand3HysteresisZone->setMinValue(-60);
  innerItemBand3HysteresisZone->setMaxValue(0);
  itemBand3HysteresisZone->setWriteFlags(KConfigBase::Notify);
  itemBand3HysteresisZone->setGroup(cgMultibandGateinstanceIndex);
  addItem( itemBand3HysteresisZone, QStringLiteral( "band3HysteresisZone" ) );
  KConfigCompilerSignallingItem  *itemBand4HysteresisZone;
  KConfigBaseEE::ItemDouble  *innerItemBand4HysteresisZone;
  innerItemBand4HysteresisZone = new KConfigBaseEE::ItemDouble( currentGroup(), QStringLiteral( "band4HysteresisZone" ), mBand4HysteresisZone, -6 );
  itemBand4HysteresisZone = new KConfigCompilerSignallingItem(innerItemBand4HysteresisZone, this, notifyFunction, signalBand4HysteresisZoneChanged);
  innerItemBand4HysteresisZone->setMinValue(-60);
  innerItemBand4HysteresisZone->setMaxValue(0);
  itemBand4HysteresisZone->setWriteFlags(KConfigBase::Notify);
  itemBand4HysteresisZone->setGroup(cgMultibandGateinstanceIndex);
  addItem( itemBand4HysteresisZone, QStringLiteral( "band4HysteresisZone" ) );
  KConfigCompilerSignallingItem  *itemBand5HysteresisZone;
  KConfigBaseEE::ItemDouble  *innerItemBand5HysteresisZone;
  innerItemBand5HysteresisZone = new KConfigBaseEE::ItemDouble( currentGroup(), QStringLiteral( "band5HysteresisZone" ), mBand5HysteresisZone, -6 );
  itemBand5HysteresisZone = new KConfigCompilerSignallingItem(innerItemBand5HysteresisZone, this, notifyFunction, signalBand5HysteresisZoneChanged);
  innerItemBand5HysteresisZone->setMinValue(-60);
  innerItemBand5HysteresisZone->setMaxValue(0);
  itemBand5HysteresisZone->setWriteFlags(KConfigBase::Notify);
  itemBand5HysteresisZone->setGroup(cgMultibandGateinstanceIndex);
  addItem( itemBand5HysteresisZone, QStringLiteral( "band5HysteresisZone" ) );
  KConfigCompilerSignallingItem  *itemBand6HysteresisZone;
  KConfigBaseEE::ItemDouble  *innerItemBand6HysteresisZone;
  innerItemBand6HysteresisZone = new KConfigBaseEE::ItemDouble( currentGroup(), QStringLiteral( "band6HysteresisZone" ), mBand6HysteresisZone, -6 );
  itemBand6HysteresisZone = new KConfigCompilerSignallingItem(innerItemBand6HysteresisZone, this, notifyFunction, signalBand6HysteresisZoneChanged);
  innerItemBand6HysteresisZone->setMinValue(-60);
  innerItemBand6HysteresisZone->setMaxValue(0);
  itemBand6HysteresisZone->setWriteFlags(KConfigBase::Notify);
  itemBand6HysteresisZone->setGroup(cgMultibandGateinstanceIndex);
  addItem( itemBand6HysteresisZone, QStringLiteral( "band6HysteresisZone" ) );
  KConfigCompilerSignallingItem  *itemBand7HysteresisZone;
  KConfigBaseEE::ItemDouble  *innerItemBand7HysteresisZone;
  innerItemBand7HysteresisZone = new KConfigBaseEE::ItemDouble( currentGroup(), QStringLiteral( "band7HysteresisZone" ), mBand7HysteresisZone, -6 );
  itemBand7HysteresisZone = new KConfigCompilerSignallingItem(innerItemBand7HysteresisZone, this, notifyFunction, signalBand7HysteresisZoneChanged);
  innerItemBand7HysteresisZone->setMinValue(-60);
  innerItemBand7HysteresisZone->setMaxValue(0);
  itemBand7HysteresisZone->setWriteFlags(KConfigBase::Notify);
  itemBand7HysteresisZone->setGroup(cgMultibandGateinstanceIndex);
  addItem( itemBand7HysteresisZone, QStringLiteral( "band7HysteresisZone" ) );
  KConfigCompilerSignallingItem  *itemBand0CurveThreshold;
  KConfigBaseEE::ItemDouble  *innerItemBand0CurveThreshold;
  innerItemBand0CurveThreshold = new KConfigBaseEE::ItemDouble( currentGroup(), QStringLiteral( "band0CurveThreshold" ), mBand0CurveThreshold, -24 );
  itemBand0CurveThreshold = new KConfigCompilerSignallingItem(innerItemBand0CurveThreshold, this, notifyFunction, signalBand0CurveThresholdChanged);
  innerItemBand0CurveThreshold->setMinValue(-60);
  innerItemBand0CurveThreshold->setMaxValue(0);
  itemBand0CurveThreshold->setWriteFlags(KConfigBase::Notify);
  itemBand0CurveThreshold->setGroup(cgMultibandGateinstanceIndex);
  addItem( itemBand0CurveThreshold, QStringLiteral( "band0CurveThreshold" ) );
  KConfigCompilerSignallingItem  *itemBand1CurveThreshold;
  KConfigBaseEE::ItemDouble  *innerItemBand1CurveThreshold;
  innerItemBand1CurveThreshold = new KConfigBaseEE::ItemDouble( currentGroup(), QStringLiteral( "band1CurveThreshold" ), mBand1CurveThreshold, -24 );
  itemBand1CurveThreshold = new KConfigCompilerSignallingItem(innerItemBand1CurveThreshold, this, notifyFunction, signalBand1CurveThresholdChanged);
  innerItemBand1CurveThreshold->setMinValue(-60);
  innerItemBand1CurveThreshold->setMaxValue(0);
  itemBand1CurveThreshold->setWriteFlags(KConfigBase::Notify);
  itemBand1CurveThreshold->setGroup(cgMultibandGateinstanceIndex);
  addItem( itemBand1CurveThreshold, QStringLiteral( "band1CurveThreshold" ) );
  KConfigCompilerSignallingItem  *itemBand2CurveThreshold;
  KConfigBaseEE::ItemDouble  *innerItemBand2CurveThreshold;
  innerItemBand2CurveThreshold = new KConfigBaseEE::ItemDouble( currentGroup(), QStringLiteral( "band2CurveThreshold" ), mBand2CurveThreshold, -24 );
  itemBand2CurveThreshold = new KConfigCompilerSignallingItem(innerItemBand2CurveThreshold, this, notifyFunction, signalBand2CurveThresholdChanged);
  innerItemBand2CurveThreshold->setMinValue(-60);
  innerItemBand2CurveThreshold->setMaxValue(0);
  itemBand2CurveThreshold->setWriteFlags(KConfigBase::Notify);
  itemBand2CurveThreshold->setGroup(cgMultibandGateinstanceIndex);
  addItem( itemBand2CurveThreshold, QStringLiteral( "band2CurveThreshold" ) );
  KConfigCompilerSignallingItem  *itemBand3CurveThreshold;
  KConfigBaseEE::ItemDouble  *innerItemBand3CurveThreshold;
  innerItemBand3CurveThreshold = new KConfigBaseEE::ItemDouble( currentGroup(), QStringLiteral( "band3CurveThreshold" ), mBand3CurveThreshold, -24 );
  itemBand3CurveThreshold = new KConfigCompilerSignallingItem(innerItemBand3CurveThreshold, this, notifyFunction, signalBand3CurveThresholdChanged);
  innerItemBand3CurveThreshold->setMinValue(-60);
  innerItemBand3CurveThreshold->setMaxValue(0);
  itemBand3CurveThreshold->setWriteFlags(KConfigBase::Notify);
  itemBand3CurveThreshold->setGroup(cgMultibandGateinstanceIndex);
  addItem( itemBand3CurveThreshold, QStringLiteral( "band3CurveThreshold" ) );
  KConfigCompilerSignallingItem  *itemBand4CurveThreshold;
  KConfigBaseEE::ItemDouble  *innerItemBand4CurveThreshold;
  innerItemBand4CurveThreshold = new KConfigBaseEE::ItemDouble( currentGroup(), QStringLiteral( "band4CurveThreshold" ), mBand4CurveThreshold, -24 );
  itemBand4CurveThreshold = new KConfigCompilerSignallingItem(innerItemBand4CurveThreshold, this, notifyFunction, signalBand4CurveThresholdChanged);
  innerItemBand4CurveThreshold->setMinValue(-60);
  innerItemBand4CurveThreshold->setMaxValue(0);
  itemBand4CurveThreshold->setWriteFlags(KConfigBase::Notify);
  itemBand4CurveThreshold->setGroup(cgMultibandGateinstanceIndex);
  addItem( itemBand4CurveThreshold, QStringLiteral( "band4CurveThreshold" ) );
  KConfigCompilerSignallingItem  *itemBand5CurveThreshold;
  KConfigBaseEE::ItemDouble  *innerItemBand5CurveThreshold;
  innerItemBand5CurveThreshold = new KConfigBaseEE::ItemDouble( currentGroup(), QStringLiteral( "band5CurveThreshold" ), mBand5CurveThreshold, -24 );
  itemBand5CurveThreshold = new KConfigCompilerSignallingItem(innerItemBand5CurveThreshold, this, notifyFunction, signalBand5CurveThresholdChanged);
  innerItemBand5CurveThreshold->setMinValue(-60);
  innerItemBand5CurveThreshold->setMaxValue(0);
  itemBand5CurveThreshold->setWriteFlags(KConfigBase::Notify);
  itemBand5CurveThreshold->setGroup(cgMultibandGateinstanceIndex);
  addItem( itemBand5CurveThreshold, QStringLiteral( "band5CurveThreshold" ) );
  KConfigCompilerSignallingItem  *itemBand6CurveThreshold;
  KConfigBaseEE::ItemDouble  *innerItemBand6CurveThreshold;
  innerItemBand6CurveThreshold = new KConfigBaseEE::ItemDouble( currentGroup(), QStringLiteral( "band6CurveThreshold" ), mBand6CurveThreshold, -24 );
  itemBand6CurveThreshold = new KConfigCompilerSignallingItem(innerItemBand6CurveThreshold, this, notifyFunction, signalBand6CurveThresholdChanged);
  innerItemBand6CurveThreshold->setMinValue(-60);
  innerItemBand6CurveThreshold->setMaxValue(0);
  itemBand6CurveThreshold->setWriteFlags(KConfigBase::Notify);
  itemBand6CurveThreshold->setGroup(cgMultibandGateinstanceIndex);
  addItem( itemBand6CurveThreshold, QStringLiteral( "band6CurveThreshold" ) );
  KConfigCompilerSignallingItem  *itemBand7CurveThreshold;
  KConfigBaseEE::ItemDouble  *innerItemBand7CurveThreshold;
  innerItemBand7CurveThreshold = new KConfigBaseEE::ItemDouble( currentGroup(), QStringLiteral( "band7CurveThreshold" ), mBand7CurveThreshold, -24 );
  itemBand7CurveThreshold = new KConfigCompilerSignallingItem(innerItemBand7CurveThreshold, this, notifyFunction, signalBand7CurveThresholdChanged);
  innerItemBand7CurveThreshold->setMinValue(-60);
  innerItemBand7CurveThreshold->setMaxValue(0);
  itemBand7CurveThreshold->setWriteFlags(KConfigBase::Notify);
  itemBand7CurveThreshold->setGroup(cgMultibandGateinstanceIndex);
  addItem( itemBand7CurveThreshold, QStringLiteral( "band7CurveThreshold" ) );
  KConfigCompilerSignallingItem  *itemBand0CurveZone;
  KConfigBaseEE::ItemDouble  *innerItemBand0CurveZone;
  innerItemBand0CurveZone = new KConfigBaseEE::ItemDouble( currentGroup(), QStringLiteral( "band0CurveZone" ), mBand0CurveZone, -6 );
  itemBand0CurveZone = new KConfigCompilerSignallingItem(innerItemBand0CurveZone, this, notifyFunction, signalBand0CurveZoneChanged);
  innerItemBand0CurveZone->setMinValue(-60);
  innerItemBand0CurveZone->setMaxValue(0);
  itemBand0CurveZone->setWriteFlags(KConfigBase::Notify);
  itemBand0CurveZone->setGroup(cgMultibandGateinstanceIndex);
  addItem( itemBand0CurveZone, QStringLiteral( "band0CurveZone" ) );
  KConfigCompilerSignallingItem  *itemBand1CurveZone;
  KConfigBaseEE::ItemDouble  *innerItemBand1CurveZone;
  innerItemBand1CurveZone = new KConfigBaseEE::ItemDouble( currentGroup(), QStringLiteral( "band1CurveZone" ), mBand1CurveZone, -6 );
  itemBand1CurveZone = new KConfigCompilerSignallingItem(innerItemBand1CurveZone, this, notifyFunction, signalBand1CurveZoneChanged);
  innerItemBand1CurveZone->setMinValue(-60);
  innerItemBand1CurveZone->setMaxValue(0);
  itemBand1CurveZone->setWriteFlags(KConfigBase::Notify);
  itemBand1CurveZone->setGroup(cgMultibandGateinstanceIndex);
  addItem( itemBand1CurveZone, QStringLiteral( "band1CurveZone" ) );
  KConfigCompilerSignallingItem  *itemBand2CurveZone;
  KConfigBaseEE::ItemDouble  *innerItemBand2CurveZone;
  innerItemBand2CurveZone = new KConfigBaseEE::ItemDouble( currentGroup(), QStringLiteral( "band2CurveZone" ), mBand2CurveZone, -6 );
  itemBand2CurveZone = new KConfigCompilerSignallingItem(innerItemBand2CurveZone, this, notifyFunction, signalBand2CurveZoneChanged);
  innerItemBand2CurveZone->setMinValue(-60);
  innerItemBand2CurveZone->setMaxValue(0);
  itemBand2CurveZone->setWriteFlags(KConfigBase::Notify);
  itemBand2CurveZone->setGroup(cgMultibandGateinstanceIndex);
  addItem( itemBand2CurveZone, QStringLiteral( "band2CurveZone" ) );
  KConfigCompilerSignallingItem  *itemBand3CurveZone;
  KConfigBaseEE::ItemDouble  *innerItemBand3CurveZone;
  innerItemBand3CurveZone = new KConfigBaseEE::ItemDouble( currentGroup(), QStringLiteral( "band3CurveZone" ), mBand3CurveZone, -6 );
  itemBand3CurveZone = new KConfigCompilerSignallingItem(innerItemBand3CurveZone, this, notifyFunction, signalBand3CurveZoneChanged);
  innerItemBand3CurveZone->setMinValue(-60);
  innerItemBand3CurveZone->setMaxValue(0);
  itemBand3CurveZone->setWriteFlags(KConfigBase::Notify);
  itemBand3CurveZone->setGroup(cgMultibandGateinstanceIndex);
  addItem( itemBand3CurveZone, QStringLiteral( "band3CurveZone" ) );
  KConfigCompilerSignallingItem  *itemBand4CurveZone;
  KConfigBaseEE::ItemDouble  *innerItemBand4CurveZone;
  innerItemBand4CurveZone = new KConfigBaseEE::ItemDouble( currentGroup(), QStringLiteral( "band4CurveZone" ), mBand4CurveZone, -6 );
  itemBand4CurveZone = new KConfigCompilerSignallingItem(innerItemBand4CurveZone, this, notifyFunction, signalBand4CurveZoneChanged);
  innerItemBand4CurveZone->setMinValue(-60);
  innerItemBand4CurveZone->setMaxValue(0);
  itemBand4CurveZone->setWriteFlags(KConfigBase::Notify);
  itemBand4CurveZone->setGroup(cgMultibandGateinstanceIndex);
  addItem( itemBand4CurveZone, QStringLiteral( "band4CurveZone" ) );
  KConfigCompilerSignallingItem  *itemBand5CurveZone;
  KConfigBaseEE::ItemDouble  *innerItemBand5CurveZone;
  innerItemBand5CurveZone = new KConfigBaseEE::ItemDouble( currentGroup(), QStringLiteral( "band5CurveZone" ), mBand5CurveZone, -6 );
  itemBand5CurveZone = new KConfigCompilerSignallingItem(innerItemBand5CurveZone, this, notifyFunction, signalBand5CurveZoneChanged);
  innerItemBand5CurveZone->setMinValue(-60);
  innerItemBand5CurveZone->setMaxValue(0);
  itemBand5CurveZone->setWriteFlags(KConfigBase::Notify);
  itemBand5CurveZone->setGroup(cgMultibandGateinstanceIndex);
  addItem( itemBand5CurveZone, QStringLiteral( "band5CurveZone" ) );
  KConfigCompilerSignallingItem  *itemBand6CurveZone;
  KConfigBaseEE::ItemDouble  *innerItemBand6CurveZone;
  innerItemBand6CurveZone = new KConfigBaseEE::ItemDouble( currentGroup(), QStringLiteral( "band6CurveZone" ), mBand6CurveZone, -6 );
  itemBand6CurveZone = new KConfigCompilerSignallingItem(innerItemBand6CurveZone, this, notifyFunction, signalBand6CurveZoneChanged);
  innerItemBand6CurveZone->setMinValue(-60);
  innerItemBand6CurveZone->setMaxValue(0);
  itemBand6CurveZone->setWriteFlags(KConfigBase::Notify);
  itemBand6CurveZone->setGroup(cgMultibandGateinstanceIndex);
  addItem( itemBand6CurveZone, QStringLiteral( "band6CurveZone" ) );
  KConfigCompilerSignallingItem  *itemBand7CurveZone;
  KConfigBaseEE::ItemDouble  *innerItemBand7CurveZone;
  innerItemBand7CurveZone = new KConfigBaseEE::ItemDouble( currentGroup(), QStringLiteral( "band7CurveZone" ), mBand7CurveZone, -6 );
  itemBand7CurveZone = new KConfigCompilerSignallingItem(innerItemBand7CurveZone, this, notifyFunction, signalBand7CurveZoneChanged);
  innerItemBand7CurveZone->setMinValue(-60);
  innerItemBand7CurveZone->setMaxValue(0);
  itemBand7CurveZone->setWriteFlags(KConfigBase::Notify);
  itemBand7CurveZone->setGroup(cgMultibandGateinstanceIndex);
  addItem( itemBand7CurveZone, QStringLiteral( "band7CurveZone" ) );
  KConfigCompilerSignallingItem  *itemBand0Reduction;
  KConfigBaseEE::ItemDouble  *innerItemBand0Reduction;
  innerItemBand0Reduction = new KConfigBaseEE::ItemDouble( currentGroup(), QStringLiteral( "band0Reduction" ), mBand0Reduction, -24 );
  itemBand0Reduction = new KConfigCompilerSignallingItem(innerItemBand0Reduction, this, notifyFunction, signalBand0ReductionChanged);
  innerItemBand0Reduction->setMinValue(-72);
  innerItemBand0Reduction->setMaxValue(72);
  itemBand0Reduction->setWriteFlags(KConfigBase::Notify);
  itemBand0Reduction->setGroup(cgMultibandGateinstanceIndex);
  addItem( itemBand0Reduction, QStringLiteral( "band0Reduction" ) );
  KConfigCompilerSignallingItem  *itemBand1Reduction;
  KConfigBaseEE::ItemDouble  *innerItemBand1Reduction;
  innerItemBand1Reduction = new KConfigBaseEE::ItemDouble( currentGroup(), QStringLiteral( "band1Reduction" ), mBand1Reduction, -24 );
  itemBand1Reduction = new KConfigCompilerSignallingItem(innerItemBand1Reduction, this, notifyFunction, signalBand1ReductionChanged);
  innerItemBand1Reduction->setMinValue(-72);
  innerItemBand1Reduction->setMaxValue(72);
  itemBand1Reduction->setWriteFlags(KConfigBase::Notify);
  itemBand1Reduction->setGroup(cgMultibandGateinstanceIndex);
  addItem( itemBand1Reduction, QStringLiteral( "band1Reduction" ) );
  KConfigCompilerSignallingItem  *itemBand2Reduction;
  KConfigBaseEE::ItemDouble  *innerItemBand2Reduction;
  innerItemBand2Reduction = new KConfigBaseEE::ItemDouble( currentGroup(), QStringLiteral( "band2Reduction" ), mBand2Reduction, -24 );
  itemBand2Reduction = new KConfigCompilerSignallingItem(innerItemBand2Reduction, this, notifyFunction, signalBand2ReductionChanged);
  innerItemBand2Reduction->setMinValue(-72);
  innerItemBand2Reduction->setMaxValue(72);
  itemBand2Reduction->setWriteFlags(KConfigBase::Notify);
  itemBand2Reduction->setGroup(cgMultibandGateinstanceIndex);
  addItem( itemBand2Reduction, QStringLiteral( "band2Reduction" ) );
  KConfigCompilerSignallingItem  *itemBand3Reduction;
  KConfigBaseEE::ItemDouble  *innerItemBand3Reduction;
  innerItemBand3Reduction = new KConfigBaseEE::ItemDouble( currentGroup(), QStringLiteral( "band3Reduction" ), mBand3Reduction, -24 );
  itemBand3Reduction = new KConfigCompilerSignallingItem(innerItemBand3Reduction, this, notifyFunction, signalBand3ReductionChanged);
  innerItemBand3Reduction->setMinValue(-72);
  innerItemBand3Reduction->setMaxValue(72);
  itemBand3Reduction->setWriteFlags(KConfigBase::Notify);
  itemBand3Reduction->setGroup(cgMultibandGateinstanceIndex);
  addItem( itemBand3Reduction, QStringLiteral( "band3Reduction" ) );
  KConfigCompilerSignallingItem  *itemBand4Reduction;
  KConfigBaseEE::ItemDouble  *innerItemBand4Reduction;
  innerItemBand4Reduction = new KConfigBaseEE::ItemDouble( currentGroup(), QStringLiteral( "band4Reduction" ), mBand4Reduction, -24 );
  itemBand4Reduction = new KConfigCompilerSignallingItem(innerItemBand4Reduction, this, notifyFunction, signalBand4ReductionChanged);
  innerItemBand4Reduction->setMinValue(-72);
  innerItemBand4Reduction->setMaxValue(72);
  itemBand4Reduction->setWriteFlags(KConfigBase::Notify);
  itemBand4Reduction->setGroup(cgMultibandGateinstanceIndex);
  addItem( itemBand4Reduction, QStringLiteral( "band4Reduction" ) );
  KConfigCompilerSignallingItem  *itemBand5Reduction;
  KConfigBaseEE::ItemDouble  *innerItemBand5Reduction;
  innerItemBand5Reduction = new KConfigBaseEE::ItemDouble( currentGroup(), QStringLiteral( "band5Reduction" ), mBand5Reduction, -24 );
  itemBand5Reduction = new KConfigCompilerSignallingItem(innerItemBand5Reduction, this, notifyFunction, signalBand5ReductionChanged);
  innerItemBand5Reduction->setMinValue(-72);
  innerItemBand5Reduction->setMaxValue(72);
  itemBand5Reduction->setWriteFlags(KConfigBase::Notify);
  itemBand5Reduction->setGroup(cgMultibandGateinstanceIndex);
  addItem( itemBand5Reduction, QStringLiteral( "band5Reduction" ) );
  KConfigCompilerSignallingItem  *itemBand6Reduction;
  KConfigBaseEE::ItemDouble  *innerItemBand6Reduction;
  innerItemBand6Reduction = new KConfigBaseEE::ItemDouble( currentGroup(), QStringLiteral( "band6Reduction" ), mBand6Reduction, -24 );
  itemBand6Reduction = new KConfigCompilerSignallingItem(innerItemBand6Reduction, this, notifyFunction, signalBand6ReductionChanged);
  innerItemBand6Reduction->setMinValue(-72);
  innerItemBand6Reduction->setMaxValue(72);
  itemBand6Reduction->setWriteFlags(KConfigBase::Notify);
  itemBand6Reduction->setGroup(cgMultibandGateinstanceIndex);
  addItem( itemBand6Reduction, QStringLiteral( "band6Reduction" ) );
  KConfigCompilerSignallingItem  *itemBand7Reduction;
  KConfigBaseEE::ItemDouble  *innerItemBand7Reduction;
  innerItemBand7Reduction = new KConfigBaseEE::ItemDouble( currentGroup(), QStringLiteral( "band7Reduction" ), mBand7Reduction, -24 );
  itemBand7Reduction = new KConfigCompilerSignallingItem(innerItemBand7Reduction, this, notifyFunction, signalBand7ReductionChanged);
  innerItemBand7Reduction->setMinValue(-72);
  innerItemBand7Reduction->setMaxValue(72);
  itemBand7Reduction->setWriteFlags(KConfigBase::Notify);
  itemBand7Reduction->setGroup(cgMultibandGateinstanceIndex);
  addItem( itemBand7Reduction, QStringLiteral( "band7Reduction" ) );
  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(cgMultibandGateinstanceIndex);
  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(cgMultibandGateinstanceIndex);
  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(cgMultibandGateinstanceIndex);
  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(cgMultibandGateinstanceIndex);
  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(cgMultibandGateinstanceIndex);
  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(cgMultibandGateinstanceIndex);
  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(cgMultibandGateinstanceIndex);
  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(cgMultibandGateinstanceIndex);
  addItem( itemBand7Makeup, QStringLiteral( "band7Makeup" ) );
}

bool DbMultibandGate::defaultBypassValue_helper() const
{

  return false;
}

double DbMultibandGate::defaultInputGainValue_helper() const
{

  return 0;
}

double DbMultibandGate::defaultOutputGainValue_helper() const
{

  return 0;
}

double DbMultibandGate::defaultDryValue_helper() const
{

  return -80.01;
}

double DbMultibandGate::defaultWetValue_helper() const
{

  return 0;
}

bool DbMultibandGate::defaultViewSidechainValue_helper() const
{

  return false;
}

bool DbMultibandGate::defaultExternalSidechainEnabledValue_helper() const
{

  return false;
}

bool DbMultibandGate::defaultStereoSplitValue_helper() const
{

  return false;
}

QStringList DbMultibandGate::defaultGateModeLabelsValue_helper() const
{
  QStringList defaultgateModeLabels;
  defaultgateModeLabels.append( QString::fromUtf8( "Classic" ) );
  defaultgateModeLabels.append( QString::fromUtf8( "Modern" ) );
  defaultgateModeLabels.append( QString::fromUtf8( "Linear Phase" ) );

  return defaultgateModeLabels;
}

int DbMultibandGate::defaultGateModeValue_helper() const
{

  return 1;
}

QStringList DbMultibandGate::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 DbMultibandGate::defaultEnvelopeBoostValue_helper() const
{

  return 0;
}

double DbMultibandGate::defaultInputToSidechainValue_helper() const
{

  return -80.01;
}

double DbMultibandGate::defaultInputToLinkValue_helper() const
{

  return -80.01;
}

double DbMultibandGate::defaultSidechainToInputValue_helper() const
{

  return -80.01;
}

double DbMultibandGate::defaultSidechainToLinkValue_helper() const
{

  return -80.01;
}

double DbMultibandGate::defaultLinkToSidechainValue_helper() const
{

  return -80.01;
}

double DbMultibandGate::defaultLinkToInputValue_helper() const
{

  return -80.01;
}

bool DbMultibandGate::defaultBand1EnableValue_helper() const
{

  return true;
}

bool DbMultibandGate::defaultBand2EnableValue_helper() const
{

  return true;
}

bool DbMultibandGate::defaultBand3EnableValue_helper() const
{

  return true;
}

bool DbMultibandGate::defaultBand4EnableValue_helper() const
{

  return false;
}

bool DbMultibandGate::defaultBand5EnableValue_helper() const
{

  return false;
}

bool DbMultibandGate::defaultBand6EnableValue_helper() const
{

  return false;
}

bool DbMultibandGate::defaultBand7EnableValue_helper() const
{

  return false;
}

double DbMultibandGate::defaultBand1SplitFrequencyValue_helper() const
{

  return 500;
}

double DbMultibandGate::defaultBand2SplitFrequencyValue_helper() const
{

  return 1000;
}

double DbMultibandGate::defaultBand3SplitFrequencyValue_helper() const
{

  return 2000;
}

double DbMultibandGate::defaultBand4SplitFrequencyValue_helper() const
{

  return 4000;
}

double DbMultibandGate::defaultBand5SplitFrequencyValue_helper() const
{

  return 8000;
}

double DbMultibandGate::defaultBand6SplitFrequencyValue_helper() const
{

  return 12000;
}

double DbMultibandGate::defaultBand7SplitFrequencyValue_helper() const
{

  return 16000;
}

QString DbMultibandGate::defaultSidechainInputDeviceValue_helper() const
{

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

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

  return defaultsidechainTypeLabels;
}

int DbMultibandGate::defaultBand0SidechainTypeValue_helper() const
{

  return 0;
}

int DbMultibandGate::defaultBand1SidechainTypeValue_helper() const
{

  return 0;
}

int DbMultibandGate::defaultBand2SidechainTypeValue_helper() const
{

  return 0;
}

int DbMultibandGate::defaultBand3SidechainTypeValue_helper() const
{

  return 0;
}

int DbMultibandGate::defaultBand4SidechainTypeValue_helper() const
{

  return 0;
}

int DbMultibandGate::defaultBand5SidechainTypeValue_helper() const
{

  return 0;
}

int DbMultibandGate::defaultBand6SidechainTypeValue_helper() const
{

  return 0;
}

int DbMultibandGate::defaultBand7SidechainTypeValue_helper() const
{

  return 0;
}

QStringList DbMultibandGate::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 DbMultibandGate::defaultBand0SidechainModeValue_helper() const
{

  return 1;
}

int DbMultibandGate::defaultBand1SidechainModeValue_helper() const
{

  return 1;
}

int DbMultibandGate::defaultBand2SidechainModeValue_helper() const
{

  return 1;
}

int DbMultibandGate::defaultBand3SidechainModeValue_helper() const
{

  return 1;
}

int DbMultibandGate::defaultBand4SidechainModeValue_helper() const
{

  return 1;
}

int DbMultibandGate::defaultBand5SidechainModeValue_helper() const
{

  return 1;
}

int DbMultibandGate::defaultBand6SidechainModeValue_helper() const
{

  return 1;
}

int DbMultibandGate::defaultBand7SidechainModeValue_helper() const
{

  return 1;
}

QStringList DbMultibandGate::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 DbMultibandGate::defaultBand0SidechainSourceValue_helper() const
{

  return 0;
}

int DbMultibandGate::defaultBand1SidechainSourceValue_helper() const
{

  return 0;
}

int DbMultibandGate::defaultBand2SidechainSourceValue_helper() const
{

  return 0;
}

int DbMultibandGate::defaultBand3SidechainSourceValue_helper() const
{

  return 0;
}

int DbMultibandGate::defaultBand4SidechainSourceValue_helper() const
{

  return 0;
}

int DbMultibandGate::defaultBand5SidechainSourceValue_helper() const
{

  return 0;
}

int DbMultibandGate::defaultBand6SidechainSourceValue_helper() const
{

  return 0;
}

int DbMultibandGate::defaultBand7SidechainSourceValue_helper() const
{

  return 0;
}

QStringList DbMultibandGate::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 DbMultibandGate::defaultBand0StereoSplitSourceValue_helper() const
{

  return 0;
}

int DbMultibandGate::defaultBand1StereoSplitSourceValue_helper() const
{

  return 0;
}

int DbMultibandGate::defaultBand2StereoSplitSourceValue_helper() const
{

  return 0;
}

int DbMultibandGate::defaultBand3StereoSplitSourceValue_helper() const
{

  return 0;
}

int DbMultibandGate::defaultBand4StereoSplitSourceValue_helper() const
{

  return 0;
}

int DbMultibandGate::defaultBand5StereoSplitSourceValue_helper() const
{

  return 0;
}

int DbMultibandGate::defaultBand6StereoSplitSourceValue_helper() const
{

  return 0;
}

int DbMultibandGate::defaultBand7StereoSplitSourceValue_helper() const
{

  return 0;
}

double DbMultibandGate::defaultBand0SidechainLookaheadValue_helper() const
{

  return 0;
}

double DbMultibandGate::defaultBand1SidechainLookaheadValue_helper() const
{

  return 0;
}

double DbMultibandGate::defaultBand2SidechainLookaheadValue_helper() const
{

  return 0;
}

double DbMultibandGate::defaultBand3SidechainLookaheadValue_helper() const
{

  return 0;
}

double DbMultibandGate::defaultBand4SidechainLookaheadValue_helper() const
{

  return 0;
}

double DbMultibandGate::defaultBand5SidechainLookaheadValue_helper() const
{

  return 0;
}

double DbMultibandGate::defaultBand6SidechainLookaheadValue_helper() const
{

  return 0;
}

double DbMultibandGate::defaultBand7SidechainLookaheadValue_helper() const
{

  return 0;
}

double DbMultibandGate::defaultBand0SidechainReactivityValue_helper() const
{

  return 10;
}

double DbMultibandGate::defaultBand1SidechainReactivityValue_helper() const
{

  return 10;
}

double DbMultibandGate::defaultBand2SidechainReactivityValue_helper() const
{

  return 10;
}

double DbMultibandGate::defaultBand3SidechainReactivityValue_helper() const
{

  return 10;
}

double DbMultibandGate::defaultBand4SidechainReactivityValue_helper() const
{

  return 10;
}

double DbMultibandGate::defaultBand5SidechainReactivityValue_helper() const
{

  return 10;
}

double DbMultibandGate::defaultBand6SidechainReactivityValue_helper() const
{

  return 10;
}

double DbMultibandGate::defaultBand7SidechainReactivityValue_helper() const
{

  return 10;
}

double DbMultibandGate::defaultBand0SidechainPreampValue_helper() const
{

  return 0;
}

double DbMultibandGate::defaultBand1SidechainPreampValue_helper() const
{

  return 0;
}

double DbMultibandGate::defaultBand2SidechainPreampValue_helper() const
{

  return 0;
}

double DbMultibandGate::defaultBand3SidechainPreampValue_helper() const
{

  return 0;
}

double DbMultibandGate::defaultBand4SidechainPreampValue_helper() const
{

  return 0;
}

double DbMultibandGate::defaultBand5SidechainPreampValue_helper() const
{

  return 0;
}

double DbMultibandGate::defaultBand6SidechainPreampValue_helper() const
{

  return 0;
}

double DbMultibandGate::defaultBand7SidechainPreampValue_helper() const
{

  return 0;
}

bool DbMultibandGate::defaultBand0SidechainCustomLowcutFilterValue_helper() const
{

  return false;
}

bool DbMultibandGate::defaultBand1SidechainCustomLowcutFilterValue_helper() const
{

  return false;
}

bool DbMultibandGate::defaultBand2SidechainCustomLowcutFilterValue_helper() const
{

  return false;
}

bool DbMultibandGate::defaultBand3SidechainCustomLowcutFilterValue_helper() const
{

  return false;
}

bool DbMultibandGate::defaultBand4SidechainCustomLowcutFilterValue_helper() const
{

  return false;
}

bool DbMultibandGate::defaultBand5SidechainCustomLowcutFilterValue_helper() const
{

  return false;
}

bool DbMultibandGate::defaultBand6SidechainCustomLowcutFilterValue_helper() const
{

  return false;
}

bool DbMultibandGate::defaultBand7SidechainCustomLowcutFilterValue_helper() const
{

  return false;
}

bool DbMultibandGate::defaultBand0SidechainCustomHighcutFilterValue_helper() const
{

  return false;
}

bool DbMultibandGate::defaultBand1SidechainCustomHighcutFilterValue_helper() const
{

  return false;
}

bool DbMultibandGate::defaultBand2SidechainCustomHighcutFilterValue_helper() const
{

  return false;
}

bool DbMultibandGate::defaultBand3SidechainCustomHighcutFilterValue_helper() const
{

  return false;
}

bool DbMultibandGate::defaultBand4SidechainCustomHighcutFilterValue_helper() const
{

  return false;
}

bool DbMultibandGate::defaultBand5SidechainCustomHighcutFilterValue_helper() const
{

  return false;
}

bool DbMultibandGate::defaultBand6SidechainCustomHighcutFilterValue_helper() const
{

  return false;
}

bool DbMultibandGate::defaultBand7SidechainCustomHighcutFilterValue_helper() const
{

  return false;
}

double DbMultibandGate::defaultBand0SidechainLowcutFrequencyValue_helper() const
{

  return 10;
}

double DbMultibandGate::defaultBand1SidechainLowcutFrequencyValue_helper() const
{

  return 500;
}

double DbMultibandGate::defaultBand2SidechainLowcutFrequencyValue_helper() const
{

  return 1000;
}

double DbMultibandGate::defaultBand3SidechainLowcutFrequencyValue_helper() const
{

  return 2000;
}

double DbMultibandGate::defaultBand4SidechainLowcutFrequencyValue_helper() const
{

  return 4000;
}

double DbMultibandGate::defaultBand5SidechainLowcutFrequencyValue_helper() const
{

  return 8000;
}

double DbMultibandGate::defaultBand6SidechainLowcutFrequencyValue_helper() const
{

  return 12000;
}

double DbMultibandGate::defaultBand7SidechainLowcutFrequencyValue_helper() const
{

  return 16000;
}

double DbMultibandGate::defaultBand0SidechainHighcutFrequencyValue_helper() const
{

  return 500;
}

double DbMultibandGate::defaultBand1SidechainHighcutFrequencyValue_helper() const
{

  return 1000;
}

double DbMultibandGate::defaultBand2SidechainHighcutFrequencyValue_helper() const
{

  return 2000;
}

double DbMultibandGate::defaultBand3SidechainHighcutFrequencyValue_helper() const
{

  return 4000;
}

double DbMultibandGate::defaultBand4SidechainHighcutFrequencyValue_helper() const
{

  return 8000;
}

double DbMultibandGate::defaultBand5SidechainHighcutFrequencyValue_helper() const
{

  return 12000;
}

double DbMultibandGate::defaultBand6SidechainHighcutFrequencyValue_helper() const
{

  return 16000;
}

double DbMultibandGate::defaultBand7SidechainHighcutFrequencyValue_helper() const
{

  return 20000;
}

bool DbMultibandGate::defaultBand0GateEnableValue_helper() const
{

  return true;
}

bool DbMultibandGate::defaultBand1GateEnableValue_helper() const
{

  return true;
}

bool DbMultibandGate::defaultBand2GateEnableValue_helper() const
{

  return true;
}

bool DbMultibandGate::defaultBand3GateEnableValue_helper() const
{

  return true;
}

bool DbMultibandGate::defaultBand4GateEnableValue_helper() const
{

  return true;
}

bool DbMultibandGate::defaultBand5GateEnableValue_helper() const
{

  return true;
}

bool DbMultibandGate::defaultBand6GateEnableValue_helper() const
{

  return true;
}

bool DbMultibandGate::defaultBand7GateEnableValue_helper() const
{

  return true;
}

bool DbMultibandGate::defaultBand0SoloValue_helper() const
{

  return false;
}

bool DbMultibandGate::defaultBand1SoloValue_helper() const
{

  return false;
}

bool DbMultibandGate::defaultBand2SoloValue_helper() const
{

  return false;
}

bool DbMultibandGate::defaultBand3SoloValue_helper() const
{

  return false;
}

bool DbMultibandGate::defaultBand4SoloValue_helper() const
{

  return false;
}

bool DbMultibandGate::defaultBand5SoloValue_helper() const
{

  return false;
}

bool DbMultibandGate::defaultBand6SoloValue_helper() const
{

  return false;
}

bool DbMultibandGate::defaultBand7SoloValue_helper() const
{

  return false;
}

bool DbMultibandGate::defaultBand0MuteValue_helper() const
{

  return false;
}

bool DbMultibandGate::defaultBand1MuteValue_helper() const
{

  return false;
}

bool DbMultibandGate::defaultBand2MuteValue_helper() const
{

  return false;
}

bool DbMultibandGate::defaultBand3MuteValue_helper() const
{

  return false;
}

bool DbMultibandGate::defaultBand4MuteValue_helper() const
{

  return false;
}

bool DbMultibandGate::defaultBand5MuteValue_helper() const
{

  return false;
}

bool DbMultibandGate::defaultBand6MuteValue_helper() const
{

  return false;
}

bool DbMultibandGate::defaultBand7MuteValue_helper() const
{

  return false;
}

double DbMultibandGate::defaultBand0AttackTimeValue_helper() const
{

  return 20;
}

double DbMultibandGate::defaultBand1AttackTimeValue_helper() const
{

  return 20;
}

double DbMultibandGate::defaultBand2AttackTimeValue_helper() const
{

  return 20;
}

double DbMultibandGate::defaultBand3AttackTimeValue_helper() const
{

  return 20;
}

double DbMultibandGate::defaultBand4AttackTimeValue_helper() const
{

  return 20;
}

double DbMultibandGate::defaultBand5AttackTimeValue_helper() const
{

  return 20;
}

double DbMultibandGate::defaultBand6AttackTimeValue_helper() const
{

  return 20;
}

double DbMultibandGate::defaultBand7AttackTimeValue_helper() const
{

  return 20;
}

double DbMultibandGate::defaultBand0ReleaseTimeValue_helper() const
{

  return 100;
}

double DbMultibandGate::defaultBand1ReleaseTimeValue_helper() const
{

  return 100;
}

double DbMultibandGate::defaultBand2ReleaseTimeValue_helper() const
{

  return 100;
}

double DbMultibandGate::defaultBand3ReleaseTimeValue_helper() const
{

  return 100;
}

double DbMultibandGate::defaultBand4ReleaseTimeValue_helper() const
{

  return 100;
}

double DbMultibandGate::defaultBand5ReleaseTimeValue_helper() const
{

  return 100;
}

double DbMultibandGate::defaultBand6ReleaseTimeValue_helper() const
{

  return 100;
}

double DbMultibandGate::defaultBand7ReleaseTimeValue_helper() const
{

  return 100;
}

bool DbMultibandGate::defaultBand0HysteresisValue_helper() const
{

  return false;
}

bool DbMultibandGate::defaultBand1HysteresisValue_helper() const
{

  return false;
}

bool DbMultibandGate::defaultBand2HysteresisValue_helper() const
{

  return false;
}

bool DbMultibandGate::defaultBand3HysteresisValue_helper() const
{

  return false;
}

bool DbMultibandGate::defaultBand4HysteresisValue_helper() const
{

  return false;
}

bool DbMultibandGate::defaultBand5HysteresisValue_helper() const
{

  return false;
}

bool DbMultibandGate::defaultBand6HysteresisValue_helper() const
{

  return false;
}

bool DbMultibandGate::defaultBand7HysteresisValue_helper() const
{

  return false;
}

double DbMultibandGate::defaultBand0HysteresisThresholdValue_helper() const
{

  return -12;
}

double DbMultibandGate::defaultBand1HysteresisThresholdValue_helper() const
{

  return -12;
}

double DbMultibandGate::defaultBand2HysteresisThresholdValue_helper() const
{

  return -12;
}

double DbMultibandGate::defaultBand3HysteresisThresholdValue_helper() const
{

  return -12;
}

double DbMultibandGate::defaultBand4HysteresisThresholdValue_helper() const
{

  return -12;
}

double DbMultibandGate::defaultBand5HysteresisThresholdValue_helper() const
{

  return -12;
}

double DbMultibandGate::defaultBand6HysteresisThresholdValue_helper() const
{

  return -12;
}

double DbMultibandGate::defaultBand7HysteresisThresholdValue_helper() const
{

  return -12;
}

double DbMultibandGate::defaultBand0HysteresisZoneValue_helper() const
{

  return -6;
}

double DbMultibandGate::defaultBand1HysteresisZoneValue_helper() const
{

  return -6;
}

double DbMultibandGate::defaultBand2HysteresisZoneValue_helper() const
{

  return -6;
}

double DbMultibandGate::defaultBand3HysteresisZoneValue_helper() const
{

  return -6;
}

double DbMultibandGate::defaultBand4HysteresisZoneValue_helper() const
{

  return -6;
}

double DbMultibandGate::defaultBand5HysteresisZoneValue_helper() const
{

  return -6;
}

double DbMultibandGate::defaultBand6HysteresisZoneValue_helper() const
{

  return -6;
}

double DbMultibandGate::defaultBand7HysteresisZoneValue_helper() const
{

  return -6;
}

double DbMultibandGate::defaultBand0CurveThresholdValue_helper() const
{

  return -24;
}

double DbMultibandGate::defaultBand1CurveThresholdValue_helper() const
{

  return -24;
}

double DbMultibandGate::defaultBand2CurveThresholdValue_helper() const
{

  return -24;
}

double DbMultibandGate::defaultBand3CurveThresholdValue_helper() const
{

  return -24;
}

double DbMultibandGate::defaultBand4CurveThresholdValue_helper() const
{

  return -24;
}

double DbMultibandGate::defaultBand5CurveThresholdValue_helper() const
{

  return -24;
}

double DbMultibandGate::defaultBand6CurveThresholdValue_helper() const
{

  return -24;
}

double DbMultibandGate::defaultBand7CurveThresholdValue_helper() const
{

  return -24;
}

double DbMultibandGate::defaultBand0CurveZoneValue_helper() const
{

  return -6;
}

double DbMultibandGate::defaultBand1CurveZoneValue_helper() const
{

  return -6;
}

double DbMultibandGate::defaultBand2CurveZoneValue_helper() const
{

  return -6;
}

double DbMultibandGate::defaultBand3CurveZoneValue_helper() const
{

  return -6;
}

double DbMultibandGate::defaultBand4CurveZoneValue_helper() const
{

  return -6;
}

double DbMultibandGate::defaultBand5CurveZoneValue_helper() const
{

  return -6;
}

double DbMultibandGate::defaultBand6CurveZoneValue_helper() const
{

  return -6;
}

double DbMultibandGate::defaultBand7CurveZoneValue_helper() const
{

  return -6;
}

double DbMultibandGate::defaultBand0ReductionValue_helper() const
{

  return -24;
}

double DbMultibandGate::defaultBand1ReductionValue_helper() const
{

  return -24;
}

double DbMultibandGate::defaultBand2ReductionValue_helper() const
{

  return -24;
}

double DbMultibandGate::defaultBand3ReductionValue_helper() const
{

  return -24;
}

double DbMultibandGate::defaultBand4ReductionValue_helper() const
{

  return -24;
}

double DbMultibandGate::defaultBand5ReductionValue_helper() const
{

  return -24;
}

double DbMultibandGate::defaultBand6ReductionValue_helper() const
{

  return -24;
}

double DbMultibandGate::defaultBand7ReductionValue_helper() const
{

  return -24;
}

double DbMultibandGate::defaultBand0MakeupValue_helper() const
{

  return 0;
}

double DbMultibandGate::defaultBand1MakeupValue_helper() const
{

  return 0;
}

double DbMultibandGate::defaultBand2MakeupValue_helper() const
{

  return 0;
}

double DbMultibandGate::defaultBand3MakeupValue_helper() const
{

  return 0;
}

double DbMultibandGate::defaultBand4MakeupValue_helper() const
{

  return 0;
}

double DbMultibandGate::defaultBand5MakeupValue_helper() const
{

  return 0;
}

double DbMultibandGate::defaultBand6MakeupValue_helper() const
{

  return 0;
}

double DbMultibandGate::defaultBand7MakeupValue_helper() const
{

  return 0;
}

DbMultibandGate::~DbMultibandGate()
{
}


void DbMultibandGate::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 signalGateModeLabelsChanged:
    Q_EMIT gateModeLabelsChanged();
    break;
  case signalGateModeChanged:
    Q_EMIT gateModeChanged();
    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 signalBand0GateEnableChanged:
    Q_EMIT band0GateEnableChanged();
    break;
  case signalBand1GateEnableChanged:
    Q_EMIT band1GateEnableChanged();
    break;
  case signalBand2GateEnableChanged:
    Q_EMIT band2GateEnableChanged();
    break;
  case signalBand3GateEnableChanged:
    Q_EMIT band3GateEnableChanged();
    break;
  case signalBand4GateEnableChanged:
    Q_EMIT band4GateEnableChanged();
    break;
  case signalBand5GateEnableChanged:
    Q_EMIT band5GateEnableChanged();
    break;
  case signalBand6GateEnableChanged:
    Q_EMIT band6GateEnableChanged();
    break;
  case signalBand7GateEnableChanged:
    Q_EMIT band7GateEnableChanged();
    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 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 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 signalBand0HysteresisChanged:
    Q_EMIT band0HysteresisChanged();
    break;
  case signalBand1HysteresisChanged:
    Q_EMIT band1HysteresisChanged();
    break;
  case signalBand2HysteresisChanged:
    Q_EMIT band2HysteresisChanged();
    break;
  case signalBand3HysteresisChanged:
    Q_EMIT band3HysteresisChanged();
    break;
  case signalBand4HysteresisChanged:
    Q_EMIT band4HysteresisChanged();
    break;
  case signalBand5HysteresisChanged:
    Q_EMIT band5HysteresisChanged();
    break;
  case signalBand6HysteresisChanged:
    Q_EMIT band6HysteresisChanged();
    break;
  case signalBand7HysteresisChanged:
    Q_EMIT band7HysteresisChanged();
    break;
  case signalBand0HysteresisThresholdChanged:
    Q_EMIT band0HysteresisThresholdChanged();
    break;
  case signalBand1HysteresisThresholdChanged:
    Q_EMIT band1HysteresisThresholdChanged();
    break;
  case signalBand2HysteresisThresholdChanged:
    Q_EMIT band2HysteresisThresholdChanged();
    break;
  case signalBand3HysteresisThresholdChanged:
    Q_EMIT band3HysteresisThresholdChanged();
    break;
  case signalBand4HysteresisThresholdChanged:
    Q_EMIT band4HysteresisThresholdChanged();
    break;
  case signalBand5HysteresisThresholdChanged:
    Q_EMIT band5HysteresisThresholdChanged();
    break;
  case signalBand6HysteresisThresholdChanged:
    Q_EMIT band6HysteresisThresholdChanged();
    break;
  case signalBand7HysteresisThresholdChanged:
    Q_EMIT band7HysteresisThresholdChanged();
    break;
  case signalBand0HysteresisZoneChanged:
    Q_EMIT band0HysteresisZoneChanged();
    break;
  case signalBand1HysteresisZoneChanged:
    Q_EMIT band1HysteresisZoneChanged();
    break;
  case signalBand2HysteresisZoneChanged:
    Q_EMIT band2HysteresisZoneChanged();
    break;
  case signalBand3HysteresisZoneChanged:
    Q_EMIT band3HysteresisZoneChanged();
    break;
  case signalBand4HysteresisZoneChanged:
    Q_EMIT band4HysteresisZoneChanged();
    break;
  case signalBand5HysteresisZoneChanged:
    Q_EMIT band5HysteresisZoneChanged();
    break;
  case signalBand6HysteresisZoneChanged:
    Q_EMIT band6HysteresisZoneChanged();
    break;
  case signalBand7HysteresisZoneChanged:
    Q_EMIT band7HysteresisZoneChanged();
    break;
  case signalBand0CurveThresholdChanged:
    Q_EMIT band0CurveThresholdChanged();
    break;
  case signalBand1CurveThresholdChanged:
    Q_EMIT band1CurveThresholdChanged();
    break;
  case signalBand2CurveThresholdChanged:
    Q_EMIT band2CurveThresholdChanged();
    break;
  case signalBand3CurveThresholdChanged:
    Q_EMIT band3CurveThresholdChanged();
    break;
  case signalBand4CurveThresholdChanged:
    Q_EMIT band4CurveThresholdChanged();
    break;
  case signalBand5CurveThresholdChanged:
    Q_EMIT band5CurveThresholdChanged();
    break;
  case signalBand6CurveThresholdChanged:
    Q_EMIT band6CurveThresholdChanged();
    break;
  case signalBand7CurveThresholdChanged:
    Q_EMIT band7CurveThresholdChanged();
    break;
  case signalBand0CurveZoneChanged:
    Q_EMIT band0CurveZoneChanged();
    break;
  case signalBand1CurveZoneChanged:
    Q_EMIT band1CurveZoneChanged();
    break;
  case signalBand2CurveZoneChanged:
    Q_EMIT band2CurveZoneChanged();
    break;
  case signalBand3CurveZoneChanged:
    Q_EMIT band3CurveZoneChanged();
    break;
  case signalBand4CurveZoneChanged:
    Q_EMIT band4CurveZoneChanged();
    break;
  case signalBand5CurveZoneChanged:
    Q_EMIT band5CurveZoneChanged();
    break;
  case signalBand6CurveZoneChanged:
    Q_EMIT band6CurveZoneChanged();
    break;
  case signalBand7CurveZoneChanged:
    Q_EMIT band7CurveZoneChanged();
    break;
  case signalBand0ReductionChanged:
    Q_EMIT band0ReductionChanged();
    break;
  case signalBand1ReductionChanged:
    Q_EMIT band1ReductionChanged();
    break;
  case signalBand2ReductionChanged:
    Q_EMIT band2ReductionChanged();
    break;
  case signalBand3ReductionChanged:
    Q_EMIT band3ReductionChanged();
    break;
  case signalBand4ReductionChanged:
    Q_EMIT band4ReductionChanged();
    break;
  case signalBand5ReductionChanged:
    Q_EMIT band5ReductionChanged();
    break;
  case signalBand6ReductionChanged:
    Q_EMIT band6ReductionChanged();
    break;
  case signalBand7ReductionChanged:
    Q_EMIT band7ReductionChanged();
    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;
  }
}
