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

#include "easyeffects_db_equalizer_channel.h"

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

  KConfigGroup cgmasterGroup(this->config(), QStringLiteral( "%1" ).arg( mParammasterGroup ));
  KConfigGroup cgEqualizerinstanceIndexchannel = cgmasterGroup.group(QStringLiteral( "Equalizer#%1#%2" ).arg( mParaminstanceIndex, mParamchannel ));
  QStringList defaultbandModeLabels;
  defaultbandModeLabels.append( QString::fromUtf8( "RLC (BT)" ) );
  defaultbandModeLabels.append( QString::fromUtf8( "RLC (MT)" ) );
  defaultbandModeLabels.append( QString::fromUtf8( "BWC (BT)" ) );
  defaultbandModeLabels.append( QString::fromUtf8( "BWC (MT)" ) );
  defaultbandModeLabels.append( QString::fromUtf8( "LRX (BT)" ) );
  defaultbandModeLabels.append( QString::fromUtf8( "LRX (MT)" ) );
  defaultbandModeLabels.append( QString::fromUtf8( "APO (DR)" ) );

  KConfigCompilerSignallingItem  *itemBandModeLabels;
  KConfigBaseEE::ItemStringList  *innerItemBandModeLabels;
  innerItemBandModeLabels = new KConfigBaseEE::ItemStringList( currentGroup(), QStringLiteral( "bandModeLabels" ), mBandModeLabels, defaultbandModeLabels );
  itemBandModeLabels = new KConfigCompilerSignallingItem(innerItemBandModeLabels, this, notifyFunction, signalBandModeLabelsChanged);
  itemBandModeLabels->setWriteFlags(KConfigBase::Notify);
  itemBandModeLabels->setGroup(cgEqualizerinstanceIndexchannel);
  addItem( itemBandModeLabels, QStringLiteral( "bandModeLabels" ) );
  QStringList defaultbandTypeLabels;
  defaultbandTypeLabels.append( QString::fromUtf8( "Off" ) );
  defaultbandTypeLabels.append( QString::fromUtf8( "Bell" ) );
  defaultbandTypeLabels.append( QString::fromUtf8( "Hi-pass" ) );
  defaultbandTypeLabels.append( QString::fromUtf8( "Hi-shelf" ) );
  defaultbandTypeLabels.append( QString::fromUtf8( "Lo-pass" ) );
  defaultbandTypeLabels.append( QString::fromUtf8( "Lo-shelf" ) );
  defaultbandTypeLabels.append( QString::fromUtf8( "Notch" ) );
  defaultbandTypeLabels.append( QString::fromUtf8( "Resonance" ) );
  defaultbandTypeLabels.append( QString::fromUtf8( "Allpass" ) );
  defaultbandTypeLabels.append( QString::fromUtf8( "Bandpass" ) );
  defaultbandTypeLabels.append( QString::fromUtf8( "Ladder-pass" ) );
  defaultbandTypeLabels.append( QString::fromUtf8( "Ladder-rej" ) );

  KConfigCompilerSignallingItem  *itemBandTypeLabels;
  KConfigBaseEE::ItemStringList  *innerItemBandTypeLabels;
  innerItemBandTypeLabels = new KConfigBaseEE::ItemStringList( currentGroup(), QStringLiteral( "bandTypeLabels" ), mBandTypeLabels, defaultbandTypeLabels );
  itemBandTypeLabels = new KConfigCompilerSignallingItem(innerItemBandTypeLabels, this, notifyFunction, signalBandTypeLabelsChanged);
  itemBandTypeLabels->setWriteFlags(KConfigBase::Notify);
  itemBandTypeLabels->setGroup(cgEqualizerinstanceIndexchannel);
  addItem( itemBandTypeLabels, QStringLiteral( "bandTypeLabels" ) );
  QStringList defaultbandSlopeLabels;
  defaultbandSlopeLabels.append( QString::fromUtf8( "x1" ) );
  defaultbandSlopeLabels.append( QString::fromUtf8( "x2" ) );
  defaultbandSlopeLabels.append( QString::fromUtf8( "x3" ) );
  defaultbandSlopeLabels.append( QString::fromUtf8( "x4" ) );

  KConfigCompilerSignallingItem  *itemBandSlopeLabels;
  KConfigBaseEE::ItemStringList  *innerItemBandSlopeLabels;
  innerItemBandSlopeLabels = new KConfigBaseEE::ItemStringList( currentGroup(), QStringLiteral( "bandSlopeLabels" ), mBandSlopeLabels, defaultbandSlopeLabels );
  itemBandSlopeLabels = new KConfigCompilerSignallingItem(innerItemBandSlopeLabels, this, notifyFunction, signalBandSlopeLabelsChanged);
  itemBandSlopeLabels->setWriteFlags(KConfigBase::Notify);
  itemBandSlopeLabels->setGroup(cgEqualizerinstanceIndexchannel);
  addItem( itemBandSlopeLabels, QStringLiteral( "bandSlopeLabels" ) );
  KConfigCompilerSignallingItem  *itemBand0Gain;
  KConfigBaseEE::ItemDouble  *innerItemBand0Gain;
  innerItemBand0Gain = new KConfigBaseEE::ItemDouble( currentGroup(), QStringLiteral( "band0Gain" ), mBand0Gain, 0 );
  itemBand0Gain = new KConfigCompilerSignallingItem(innerItemBand0Gain, this, notifyFunction, signalBand0GainChanged);
  innerItemBand0Gain->setMinValue(-36);
  innerItemBand0Gain->setMaxValue(36);
  itemBand0Gain->setWriteFlags(KConfigBase::Notify);
  itemBand0Gain->setGroup(cgEqualizerinstanceIndexchannel);
  addItem( itemBand0Gain, QStringLiteral( "band0Gain" ) );
  KConfigCompilerSignallingItem  *itemBand1Gain;
  KConfigBaseEE::ItemDouble  *innerItemBand1Gain;
  innerItemBand1Gain = new KConfigBaseEE::ItemDouble( currentGroup(), QStringLiteral( "band1Gain" ), mBand1Gain, 0 );
  itemBand1Gain = new KConfigCompilerSignallingItem(innerItemBand1Gain, this, notifyFunction, signalBand1GainChanged);
  innerItemBand1Gain->setMinValue(-36);
  innerItemBand1Gain->setMaxValue(36);
  itemBand1Gain->setWriteFlags(KConfigBase::Notify);
  itemBand1Gain->setGroup(cgEqualizerinstanceIndexchannel);
  addItem( itemBand1Gain, QStringLiteral( "band1Gain" ) );
  KConfigCompilerSignallingItem  *itemBand2Gain;
  KConfigBaseEE::ItemDouble  *innerItemBand2Gain;
  innerItemBand2Gain = new KConfigBaseEE::ItemDouble( currentGroup(), QStringLiteral( "band2Gain" ), mBand2Gain, 0 );
  itemBand2Gain = new KConfigCompilerSignallingItem(innerItemBand2Gain, this, notifyFunction, signalBand2GainChanged);
  innerItemBand2Gain->setMinValue(-36);
  innerItemBand2Gain->setMaxValue(36);
  itemBand2Gain->setWriteFlags(KConfigBase::Notify);
  itemBand2Gain->setGroup(cgEqualizerinstanceIndexchannel);
  addItem( itemBand2Gain, QStringLiteral( "band2Gain" ) );
  KConfigCompilerSignallingItem  *itemBand3Gain;
  KConfigBaseEE::ItemDouble  *innerItemBand3Gain;
  innerItemBand3Gain = new KConfigBaseEE::ItemDouble( currentGroup(), QStringLiteral( "band3Gain" ), mBand3Gain, 0 );
  itemBand3Gain = new KConfigCompilerSignallingItem(innerItemBand3Gain, this, notifyFunction, signalBand3GainChanged);
  innerItemBand3Gain->setMinValue(-36);
  innerItemBand3Gain->setMaxValue(36);
  itemBand3Gain->setWriteFlags(KConfigBase::Notify);
  itemBand3Gain->setGroup(cgEqualizerinstanceIndexchannel);
  addItem( itemBand3Gain, QStringLiteral( "band3Gain" ) );
  KConfigCompilerSignallingItem  *itemBand4Gain;
  KConfigBaseEE::ItemDouble  *innerItemBand4Gain;
  innerItemBand4Gain = new KConfigBaseEE::ItemDouble( currentGroup(), QStringLiteral( "band4Gain" ), mBand4Gain, 0 );
  itemBand4Gain = new KConfigCompilerSignallingItem(innerItemBand4Gain, this, notifyFunction, signalBand4GainChanged);
  innerItemBand4Gain->setMinValue(-36);
  innerItemBand4Gain->setMaxValue(36);
  itemBand4Gain->setWriteFlags(KConfigBase::Notify);
  itemBand4Gain->setGroup(cgEqualizerinstanceIndexchannel);
  addItem( itemBand4Gain, QStringLiteral( "band4Gain" ) );
  KConfigCompilerSignallingItem  *itemBand5Gain;
  KConfigBaseEE::ItemDouble  *innerItemBand5Gain;
  innerItemBand5Gain = new KConfigBaseEE::ItemDouble( currentGroup(), QStringLiteral( "band5Gain" ), mBand5Gain, 0 );
  itemBand5Gain = new KConfigCompilerSignallingItem(innerItemBand5Gain, this, notifyFunction, signalBand5GainChanged);
  innerItemBand5Gain->setMinValue(-36);
  innerItemBand5Gain->setMaxValue(36);
  itemBand5Gain->setWriteFlags(KConfigBase::Notify);
  itemBand5Gain->setGroup(cgEqualizerinstanceIndexchannel);
  addItem( itemBand5Gain, QStringLiteral( "band5Gain" ) );
  KConfigCompilerSignallingItem  *itemBand6Gain;
  KConfigBaseEE::ItemDouble  *innerItemBand6Gain;
  innerItemBand6Gain = new KConfigBaseEE::ItemDouble( currentGroup(), QStringLiteral( "band6Gain" ), mBand6Gain, 0 );
  itemBand6Gain = new KConfigCompilerSignallingItem(innerItemBand6Gain, this, notifyFunction, signalBand6GainChanged);
  innerItemBand6Gain->setMinValue(-36);
  innerItemBand6Gain->setMaxValue(36);
  itemBand6Gain->setWriteFlags(KConfigBase::Notify);
  itemBand6Gain->setGroup(cgEqualizerinstanceIndexchannel);
  addItem( itemBand6Gain, QStringLiteral( "band6Gain" ) );
  KConfigCompilerSignallingItem  *itemBand7Gain;
  KConfigBaseEE::ItemDouble  *innerItemBand7Gain;
  innerItemBand7Gain = new KConfigBaseEE::ItemDouble( currentGroup(), QStringLiteral( "band7Gain" ), mBand7Gain, 0 );
  itemBand7Gain = new KConfigCompilerSignallingItem(innerItemBand7Gain, this, notifyFunction, signalBand7GainChanged);
  innerItemBand7Gain->setMinValue(-36);
  innerItemBand7Gain->setMaxValue(36);
  itemBand7Gain->setWriteFlags(KConfigBase::Notify);
  itemBand7Gain->setGroup(cgEqualizerinstanceIndexchannel);
  addItem( itemBand7Gain, QStringLiteral( "band7Gain" ) );
  KConfigCompilerSignallingItem  *itemBand8Gain;
  KConfigBaseEE::ItemDouble  *innerItemBand8Gain;
  innerItemBand8Gain = new KConfigBaseEE::ItemDouble( currentGroup(), QStringLiteral( "band8Gain" ), mBand8Gain, 0 );
  itemBand8Gain = new KConfigCompilerSignallingItem(innerItemBand8Gain, this, notifyFunction, signalBand8GainChanged);
  innerItemBand8Gain->setMinValue(-36);
  innerItemBand8Gain->setMaxValue(36);
  itemBand8Gain->setWriteFlags(KConfigBase::Notify);
  itemBand8Gain->setGroup(cgEqualizerinstanceIndexchannel);
  addItem( itemBand8Gain, QStringLiteral( "band8Gain" ) );
  KConfigCompilerSignallingItem  *itemBand9Gain;
  KConfigBaseEE::ItemDouble  *innerItemBand9Gain;
  innerItemBand9Gain = new KConfigBaseEE::ItemDouble( currentGroup(), QStringLiteral( "band9Gain" ), mBand9Gain, 0 );
  itemBand9Gain = new KConfigCompilerSignallingItem(innerItemBand9Gain, this, notifyFunction, signalBand9GainChanged);
  innerItemBand9Gain->setMinValue(-36);
  innerItemBand9Gain->setMaxValue(36);
  itemBand9Gain->setWriteFlags(KConfigBase::Notify);
  itemBand9Gain->setGroup(cgEqualizerinstanceIndexchannel);
  addItem( itemBand9Gain, QStringLiteral( "band9Gain" ) );
  KConfigCompilerSignallingItem  *itemBand10Gain;
  KConfigBaseEE::ItemDouble  *innerItemBand10Gain;
  innerItemBand10Gain = new KConfigBaseEE::ItemDouble( currentGroup(), QStringLiteral( "band10Gain" ), mBand10Gain, 0 );
  itemBand10Gain = new KConfigCompilerSignallingItem(innerItemBand10Gain, this, notifyFunction, signalBand10GainChanged);
  innerItemBand10Gain->setMinValue(-36);
  innerItemBand10Gain->setMaxValue(36);
  itemBand10Gain->setWriteFlags(KConfigBase::Notify);
  itemBand10Gain->setGroup(cgEqualizerinstanceIndexchannel);
  addItem( itemBand10Gain, QStringLiteral( "band10Gain" ) );
  KConfigCompilerSignallingItem  *itemBand11Gain;
  KConfigBaseEE::ItemDouble  *innerItemBand11Gain;
  innerItemBand11Gain = new KConfigBaseEE::ItemDouble( currentGroup(), QStringLiteral( "band11Gain" ), mBand11Gain, 0 );
  itemBand11Gain = new KConfigCompilerSignallingItem(innerItemBand11Gain, this, notifyFunction, signalBand11GainChanged);
  innerItemBand11Gain->setMinValue(-36);
  innerItemBand11Gain->setMaxValue(36);
  itemBand11Gain->setWriteFlags(KConfigBase::Notify);
  itemBand11Gain->setGroup(cgEqualizerinstanceIndexchannel);
  addItem( itemBand11Gain, QStringLiteral( "band11Gain" ) );
  KConfigCompilerSignallingItem  *itemBand12Gain;
  KConfigBaseEE::ItemDouble  *innerItemBand12Gain;
  innerItemBand12Gain = new KConfigBaseEE::ItemDouble( currentGroup(), QStringLiteral( "band12Gain" ), mBand12Gain, 0 );
  itemBand12Gain = new KConfigCompilerSignallingItem(innerItemBand12Gain, this, notifyFunction, signalBand12GainChanged);
  innerItemBand12Gain->setMinValue(-36);
  innerItemBand12Gain->setMaxValue(36);
  itemBand12Gain->setWriteFlags(KConfigBase::Notify);
  itemBand12Gain->setGroup(cgEqualizerinstanceIndexchannel);
  addItem( itemBand12Gain, QStringLiteral( "band12Gain" ) );
  KConfigCompilerSignallingItem  *itemBand13Gain;
  KConfigBaseEE::ItemDouble  *innerItemBand13Gain;
  innerItemBand13Gain = new KConfigBaseEE::ItemDouble( currentGroup(), QStringLiteral( "band13Gain" ), mBand13Gain, 0 );
  itemBand13Gain = new KConfigCompilerSignallingItem(innerItemBand13Gain, this, notifyFunction, signalBand13GainChanged);
  innerItemBand13Gain->setMinValue(-36);
  innerItemBand13Gain->setMaxValue(36);
  itemBand13Gain->setWriteFlags(KConfigBase::Notify);
  itemBand13Gain->setGroup(cgEqualizerinstanceIndexchannel);
  addItem( itemBand13Gain, QStringLiteral( "band13Gain" ) );
  KConfigCompilerSignallingItem  *itemBand14Gain;
  KConfigBaseEE::ItemDouble  *innerItemBand14Gain;
  innerItemBand14Gain = new KConfigBaseEE::ItemDouble( currentGroup(), QStringLiteral( "band14Gain" ), mBand14Gain, 0 );
  itemBand14Gain = new KConfigCompilerSignallingItem(innerItemBand14Gain, this, notifyFunction, signalBand14GainChanged);
  innerItemBand14Gain->setMinValue(-36);
  innerItemBand14Gain->setMaxValue(36);
  itemBand14Gain->setWriteFlags(KConfigBase::Notify);
  itemBand14Gain->setGroup(cgEqualizerinstanceIndexchannel);
  addItem( itemBand14Gain, QStringLiteral( "band14Gain" ) );
  KConfigCompilerSignallingItem  *itemBand15Gain;
  KConfigBaseEE::ItemDouble  *innerItemBand15Gain;
  innerItemBand15Gain = new KConfigBaseEE::ItemDouble( currentGroup(), QStringLiteral( "band15Gain" ), mBand15Gain, 0 );
  itemBand15Gain = new KConfigCompilerSignallingItem(innerItemBand15Gain, this, notifyFunction, signalBand15GainChanged);
  innerItemBand15Gain->setMinValue(-36);
  innerItemBand15Gain->setMaxValue(36);
  itemBand15Gain->setWriteFlags(KConfigBase::Notify);
  itemBand15Gain->setGroup(cgEqualizerinstanceIndexchannel);
  addItem( itemBand15Gain, QStringLiteral( "band15Gain" ) );
  KConfigCompilerSignallingItem  *itemBand16Gain;
  KConfigBaseEE::ItemDouble  *innerItemBand16Gain;
  innerItemBand16Gain = new KConfigBaseEE::ItemDouble( currentGroup(), QStringLiteral( "band16Gain" ), mBand16Gain, 0 );
  itemBand16Gain = new KConfigCompilerSignallingItem(innerItemBand16Gain, this, notifyFunction, signalBand16GainChanged);
  innerItemBand16Gain->setMinValue(-36);
  innerItemBand16Gain->setMaxValue(36);
  itemBand16Gain->setWriteFlags(KConfigBase::Notify);
  itemBand16Gain->setGroup(cgEqualizerinstanceIndexchannel);
  addItem( itemBand16Gain, QStringLiteral( "band16Gain" ) );
  KConfigCompilerSignallingItem  *itemBand17Gain;
  KConfigBaseEE::ItemDouble  *innerItemBand17Gain;
  innerItemBand17Gain = new KConfigBaseEE::ItemDouble( currentGroup(), QStringLiteral( "band17Gain" ), mBand17Gain, 0 );
  itemBand17Gain = new KConfigCompilerSignallingItem(innerItemBand17Gain, this, notifyFunction, signalBand17GainChanged);
  innerItemBand17Gain->setMinValue(-36);
  innerItemBand17Gain->setMaxValue(36);
  itemBand17Gain->setWriteFlags(KConfigBase::Notify);
  itemBand17Gain->setGroup(cgEqualizerinstanceIndexchannel);
  addItem( itemBand17Gain, QStringLiteral( "band17Gain" ) );
  KConfigCompilerSignallingItem  *itemBand18Gain;
  KConfigBaseEE::ItemDouble  *innerItemBand18Gain;
  innerItemBand18Gain = new KConfigBaseEE::ItemDouble( currentGroup(), QStringLiteral( "band18Gain" ), mBand18Gain, 0 );
  itemBand18Gain = new KConfigCompilerSignallingItem(innerItemBand18Gain, this, notifyFunction, signalBand18GainChanged);
  innerItemBand18Gain->setMinValue(-36);
  innerItemBand18Gain->setMaxValue(36);
  itemBand18Gain->setWriteFlags(KConfigBase::Notify);
  itemBand18Gain->setGroup(cgEqualizerinstanceIndexchannel);
  addItem( itemBand18Gain, QStringLiteral( "band18Gain" ) );
  KConfigCompilerSignallingItem  *itemBand19Gain;
  KConfigBaseEE::ItemDouble  *innerItemBand19Gain;
  innerItemBand19Gain = new KConfigBaseEE::ItemDouble( currentGroup(), QStringLiteral( "band19Gain" ), mBand19Gain, 0 );
  itemBand19Gain = new KConfigCompilerSignallingItem(innerItemBand19Gain, this, notifyFunction, signalBand19GainChanged);
  innerItemBand19Gain->setMinValue(-36);
  innerItemBand19Gain->setMaxValue(36);
  itemBand19Gain->setWriteFlags(KConfigBase::Notify);
  itemBand19Gain->setGroup(cgEqualizerinstanceIndexchannel);
  addItem( itemBand19Gain, QStringLiteral( "band19Gain" ) );
  KConfigCompilerSignallingItem  *itemBand20Gain;
  KConfigBaseEE::ItemDouble  *innerItemBand20Gain;
  innerItemBand20Gain = new KConfigBaseEE::ItemDouble( currentGroup(), QStringLiteral( "band20Gain" ), mBand20Gain, 0 );
  itemBand20Gain = new KConfigCompilerSignallingItem(innerItemBand20Gain, this, notifyFunction, signalBand20GainChanged);
  innerItemBand20Gain->setMinValue(-36);
  innerItemBand20Gain->setMaxValue(36);
  itemBand20Gain->setWriteFlags(KConfigBase::Notify);
  itemBand20Gain->setGroup(cgEqualizerinstanceIndexchannel);
  addItem( itemBand20Gain, QStringLiteral( "band20Gain" ) );
  KConfigCompilerSignallingItem  *itemBand21Gain;
  KConfigBaseEE::ItemDouble  *innerItemBand21Gain;
  innerItemBand21Gain = new KConfigBaseEE::ItemDouble( currentGroup(), QStringLiteral( "band21Gain" ), mBand21Gain, 0 );
  itemBand21Gain = new KConfigCompilerSignallingItem(innerItemBand21Gain, this, notifyFunction, signalBand21GainChanged);
  innerItemBand21Gain->setMinValue(-36);
  innerItemBand21Gain->setMaxValue(36);
  itemBand21Gain->setWriteFlags(KConfigBase::Notify);
  itemBand21Gain->setGroup(cgEqualizerinstanceIndexchannel);
  addItem( itemBand21Gain, QStringLiteral( "band21Gain" ) );
  KConfigCompilerSignallingItem  *itemBand22Gain;
  KConfigBaseEE::ItemDouble  *innerItemBand22Gain;
  innerItemBand22Gain = new KConfigBaseEE::ItemDouble( currentGroup(), QStringLiteral( "band22Gain" ), mBand22Gain, 0 );
  itemBand22Gain = new KConfigCompilerSignallingItem(innerItemBand22Gain, this, notifyFunction, signalBand22GainChanged);
  innerItemBand22Gain->setMinValue(-36);
  innerItemBand22Gain->setMaxValue(36);
  itemBand22Gain->setWriteFlags(KConfigBase::Notify);
  itemBand22Gain->setGroup(cgEqualizerinstanceIndexchannel);
  addItem( itemBand22Gain, QStringLiteral( "band22Gain" ) );
  KConfigCompilerSignallingItem  *itemBand23Gain;
  KConfigBaseEE::ItemDouble  *innerItemBand23Gain;
  innerItemBand23Gain = new KConfigBaseEE::ItemDouble( currentGroup(), QStringLiteral( "band23Gain" ), mBand23Gain, 0 );
  itemBand23Gain = new KConfigCompilerSignallingItem(innerItemBand23Gain, this, notifyFunction, signalBand23GainChanged);
  innerItemBand23Gain->setMinValue(-36);
  innerItemBand23Gain->setMaxValue(36);
  itemBand23Gain->setWriteFlags(KConfigBase::Notify);
  itemBand23Gain->setGroup(cgEqualizerinstanceIndexchannel);
  addItem( itemBand23Gain, QStringLiteral( "band23Gain" ) );
  KConfigCompilerSignallingItem  *itemBand24Gain;
  KConfigBaseEE::ItemDouble  *innerItemBand24Gain;
  innerItemBand24Gain = new KConfigBaseEE::ItemDouble( currentGroup(), QStringLiteral( "band24Gain" ), mBand24Gain, 0 );
  itemBand24Gain = new KConfigCompilerSignallingItem(innerItemBand24Gain, this, notifyFunction, signalBand24GainChanged);
  innerItemBand24Gain->setMinValue(-36);
  innerItemBand24Gain->setMaxValue(36);
  itemBand24Gain->setWriteFlags(KConfigBase::Notify);
  itemBand24Gain->setGroup(cgEqualizerinstanceIndexchannel);
  addItem( itemBand24Gain, QStringLiteral( "band24Gain" ) );
  KConfigCompilerSignallingItem  *itemBand25Gain;
  KConfigBaseEE::ItemDouble  *innerItemBand25Gain;
  innerItemBand25Gain = new KConfigBaseEE::ItemDouble( currentGroup(), QStringLiteral( "band25Gain" ), mBand25Gain, 0 );
  itemBand25Gain = new KConfigCompilerSignallingItem(innerItemBand25Gain, this, notifyFunction, signalBand25GainChanged);
  innerItemBand25Gain->setMinValue(-36);
  innerItemBand25Gain->setMaxValue(36);
  itemBand25Gain->setWriteFlags(KConfigBase::Notify);
  itemBand25Gain->setGroup(cgEqualizerinstanceIndexchannel);
  addItem( itemBand25Gain, QStringLiteral( "band25Gain" ) );
  KConfigCompilerSignallingItem  *itemBand26Gain;
  KConfigBaseEE::ItemDouble  *innerItemBand26Gain;
  innerItemBand26Gain = new KConfigBaseEE::ItemDouble( currentGroup(), QStringLiteral( "band26Gain" ), mBand26Gain, 0 );
  itemBand26Gain = new KConfigCompilerSignallingItem(innerItemBand26Gain, this, notifyFunction, signalBand26GainChanged);
  innerItemBand26Gain->setMinValue(-36);
  innerItemBand26Gain->setMaxValue(36);
  itemBand26Gain->setWriteFlags(KConfigBase::Notify);
  itemBand26Gain->setGroup(cgEqualizerinstanceIndexchannel);
  addItem( itemBand26Gain, QStringLiteral( "band26Gain" ) );
  KConfigCompilerSignallingItem  *itemBand27Gain;
  KConfigBaseEE::ItemDouble  *innerItemBand27Gain;
  innerItemBand27Gain = new KConfigBaseEE::ItemDouble( currentGroup(), QStringLiteral( "band27Gain" ), mBand27Gain, 0 );
  itemBand27Gain = new KConfigCompilerSignallingItem(innerItemBand27Gain, this, notifyFunction, signalBand27GainChanged);
  innerItemBand27Gain->setMinValue(-36);
  innerItemBand27Gain->setMaxValue(36);
  itemBand27Gain->setWriteFlags(KConfigBase::Notify);
  itemBand27Gain->setGroup(cgEqualizerinstanceIndexchannel);
  addItem( itemBand27Gain, QStringLiteral( "band27Gain" ) );
  KConfigCompilerSignallingItem  *itemBand28Gain;
  KConfigBaseEE::ItemDouble  *innerItemBand28Gain;
  innerItemBand28Gain = new KConfigBaseEE::ItemDouble( currentGroup(), QStringLiteral( "band28Gain" ), mBand28Gain, 0 );
  itemBand28Gain = new KConfigCompilerSignallingItem(innerItemBand28Gain, this, notifyFunction, signalBand28GainChanged);
  innerItemBand28Gain->setMinValue(-36);
  innerItemBand28Gain->setMaxValue(36);
  itemBand28Gain->setWriteFlags(KConfigBase::Notify);
  itemBand28Gain->setGroup(cgEqualizerinstanceIndexchannel);
  addItem( itemBand28Gain, QStringLiteral( "band28Gain" ) );
  KConfigCompilerSignallingItem  *itemBand29Gain;
  KConfigBaseEE::ItemDouble  *innerItemBand29Gain;
  innerItemBand29Gain = new KConfigBaseEE::ItemDouble( currentGroup(), QStringLiteral( "band29Gain" ), mBand29Gain, 0 );
  itemBand29Gain = new KConfigCompilerSignallingItem(innerItemBand29Gain, this, notifyFunction, signalBand29GainChanged);
  innerItemBand29Gain->setMinValue(-36);
  innerItemBand29Gain->setMaxValue(36);
  itemBand29Gain->setWriteFlags(KConfigBase::Notify);
  itemBand29Gain->setGroup(cgEqualizerinstanceIndexchannel);
  addItem( itemBand29Gain, QStringLiteral( "band29Gain" ) );
  KConfigCompilerSignallingItem  *itemBand30Gain;
  KConfigBaseEE::ItemDouble  *innerItemBand30Gain;
  innerItemBand30Gain = new KConfigBaseEE::ItemDouble( currentGroup(), QStringLiteral( "band30Gain" ), mBand30Gain, 0 );
  itemBand30Gain = new KConfigCompilerSignallingItem(innerItemBand30Gain, this, notifyFunction, signalBand30GainChanged);
  innerItemBand30Gain->setMinValue(-36);
  innerItemBand30Gain->setMaxValue(36);
  itemBand30Gain->setWriteFlags(KConfigBase::Notify);
  itemBand30Gain->setGroup(cgEqualizerinstanceIndexchannel);
  addItem( itemBand30Gain, QStringLiteral( "band30Gain" ) );
  KConfigCompilerSignallingItem  *itemBand31Gain;
  KConfigBaseEE::ItemDouble  *innerItemBand31Gain;
  innerItemBand31Gain = new KConfigBaseEE::ItemDouble( currentGroup(), QStringLiteral( "band31Gain" ), mBand31Gain, 0 );
  itemBand31Gain = new KConfigCompilerSignallingItem(innerItemBand31Gain, this, notifyFunction, signalBand31GainChanged);
  innerItemBand31Gain->setMinValue(-36);
  innerItemBand31Gain->setMaxValue(36);
  itemBand31Gain->setWriteFlags(KConfigBase::Notify);
  itemBand31Gain->setGroup(cgEqualizerinstanceIndexchannel);
  addItem( itemBand31Gain, QStringLiteral( "band31Gain" ) );
  KConfigCompilerSignallingItem  *itemBand0Frequency;
  KConfigBaseEE::ItemDouble  *innerItemBand0Frequency;
  innerItemBand0Frequency = new KConfigBaseEE::ItemDouble( currentGroup(), QStringLiteral( "band0Frequency" ), mBand0Frequency, 22.40 );
  itemBand0Frequency = new KConfigCompilerSignallingItem(innerItemBand0Frequency, this, notifyFunction, signalBand0FrequencyChanged);
  innerItemBand0Frequency->setMinValue(10);
  innerItemBand0Frequency->setMaxValue(24000);
  itemBand0Frequency->setWriteFlags(KConfigBase::Notify);
  itemBand0Frequency->setGroup(cgEqualizerinstanceIndexchannel);
  addItem( itemBand0Frequency, QStringLiteral( "band0Frequency" ) );
  KConfigCompilerSignallingItem  *itemBand1Frequency;
  KConfigBaseEE::ItemDouble  *innerItemBand1Frequency;
  innerItemBand1Frequency = new KConfigBaseEE::ItemDouble( currentGroup(), QStringLiteral( "band1Frequency" ), mBand1Frequency, 27.80 );
  itemBand1Frequency = new KConfigCompilerSignallingItem(innerItemBand1Frequency, this, notifyFunction, signalBand1FrequencyChanged);
  innerItemBand1Frequency->setMinValue(10);
  innerItemBand1Frequency->setMaxValue(24000);
  itemBand1Frequency->setWriteFlags(KConfigBase::Notify);
  itemBand1Frequency->setGroup(cgEqualizerinstanceIndexchannel);
  addItem( itemBand1Frequency, QStringLiteral( "band1Frequency" ) );
  KConfigCompilerSignallingItem  *itemBand2Frequency;
  KConfigBaseEE::ItemDouble  *innerItemBand2Frequency;
  innerItemBand2Frequency = new KConfigBaseEE::ItemDouble( currentGroup(), QStringLiteral( "band2Frequency" ), mBand2Frequency, 34.51 );
  itemBand2Frequency = new KConfigCompilerSignallingItem(innerItemBand2Frequency, this, notifyFunction, signalBand2FrequencyChanged);
  innerItemBand2Frequency->setMinValue(10);
  innerItemBand2Frequency->setMaxValue(24000);
  itemBand2Frequency->setWriteFlags(KConfigBase::Notify);
  itemBand2Frequency->setGroup(cgEqualizerinstanceIndexchannel);
  addItem( itemBand2Frequency, QStringLiteral( "band2Frequency" ) );
  KConfigCompilerSignallingItem  *itemBand3Frequency;
  KConfigBaseEE::ItemDouble  *innerItemBand3Frequency;
  innerItemBand3Frequency = new KConfigBaseEE::ItemDouble( currentGroup(), QStringLiteral( "band3Frequency" ), mBand3Frequency, 42.82 );
  itemBand3Frequency = new KConfigCompilerSignallingItem(innerItemBand3Frequency, this, notifyFunction, signalBand3FrequencyChanged);
  innerItemBand3Frequency->setMinValue(10);
  innerItemBand3Frequency->setMaxValue(24000);
  itemBand3Frequency->setWriteFlags(KConfigBase::Notify);
  itemBand3Frequency->setGroup(cgEqualizerinstanceIndexchannel);
  addItem( itemBand3Frequency, QStringLiteral( "band3Frequency" ) );
  KConfigCompilerSignallingItem  *itemBand4Frequency;
  KConfigBaseEE::ItemDouble  *innerItemBand4Frequency;
  innerItemBand4Frequency = new KConfigBaseEE::ItemDouble( currentGroup(), QStringLiteral( "band4Frequency" ), mBand4Frequency, 53.14 );
  itemBand4Frequency = new KConfigCompilerSignallingItem(innerItemBand4Frequency, this, notifyFunction, signalBand4FrequencyChanged);
  innerItemBand4Frequency->setMinValue(10);
  innerItemBand4Frequency->setMaxValue(24000);
  itemBand4Frequency->setWriteFlags(KConfigBase::Notify);
  itemBand4Frequency->setGroup(cgEqualizerinstanceIndexchannel);
  addItem( itemBand4Frequency, QStringLiteral( "band4Frequency" ) );
  KConfigCompilerSignallingItem  *itemBand5Frequency;
  KConfigBaseEE::ItemDouble  *innerItemBand5Frequency;
  innerItemBand5Frequency = new KConfigBaseEE::ItemDouble( currentGroup(), QStringLiteral( "band5Frequency" ), mBand5Frequency, 65.95 );
  itemBand5Frequency = new KConfigCompilerSignallingItem(innerItemBand5Frequency, this, notifyFunction, signalBand5FrequencyChanged);
  innerItemBand5Frequency->setMinValue(10);
  innerItemBand5Frequency->setMaxValue(24000);
  itemBand5Frequency->setWriteFlags(KConfigBase::Notify);
  itemBand5Frequency->setGroup(cgEqualizerinstanceIndexchannel);
  addItem( itemBand5Frequency, QStringLiteral( "band5Frequency" ) );
  KConfigCompilerSignallingItem  *itemBand6Frequency;
  KConfigBaseEE::ItemDouble  *innerItemBand6Frequency;
  innerItemBand6Frequency = new KConfigBaseEE::ItemDouble( currentGroup(), QStringLiteral( "band6Frequency" ), mBand6Frequency, 81.83 );
  itemBand6Frequency = new KConfigCompilerSignallingItem(innerItemBand6Frequency, this, notifyFunction, signalBand6FrequencyChanged);
  innerItemBand6Frequency->setMinValue(10);
  innerItemBand6Frequency->setMaxValue(24000);
  itemBand6Frequency->setWriteFlags(KConfigBase::Notify);
  itemBand6Frequency->setGroup(cgEqualizerinstanceIndexchannel);
  addItem( itemBand6Frequency, QStringLiteral( "band6Frequency" ) );
  KConfigCompilerSignallingItem  *itemBand7Frequency;
  KConfigBaseEE::ItemDouble  *innerItemBand7Frequency;
  innerItemBand7Frequency = new KConfigBaseEE::ItemDouble( currentGroup(), QStringLiteral( "band7Frequency" ), mBand7Frequency, 101.55 );
  itemBand7Frequency = new KConfigCompilerSignallingItem(innerItemBand7Frequency, this, notifyFunction, signalBand7FrequencyChanged);
  innerItemBand7Frequency->setMinValue(10);
  innerItemBand7Frequency->setMaxValue(24000);
  itemBand7Frequency->setWriteFlags(KConfigBase::Notify);
  itemBand7Frequency->setGroup(cgEqualizerinstanceIndexchannel);
  addItem( itemBand7Frequency, QStringLiteral( "band7Frequency" ) );
  KConfigCompilerSignallingItem  *itemBand8Frequency;
  KConfigBaseEE::ItemDouble  *innerItemBand8Frequency;
  innerItemBand8Frequency = new KConfigBaseEE::ItemDouble( currentGroup(), QStringLiteral( "band8Frequency" ), mBand8Frequency, 126 );
  itemBand8Frequency = new KConfigCompilerSignallingItem(innerItemBand8Frequency, this, notifyFunction, signalBand8FrequencyChanged);
  innerItemBand8Frequency->setMinValue(10);
  innerItemBand8Frequency->setMaxValue(24000);
  itemBand8Frequency->setWriteFlags(KConfigBase::Notify);
  itemBand8Frequency->setGroup(cgEqualizerinstanceIndexchannel);
  addItem( itemBand8Frequency, QStringLiteral( "band8Frequency" ) );
  KConfigCompilerSignallingItem  *itemBand9Frequency;
  KConfigBaseEE::ItemDouble  *innerItemBand9Frequency;
  innerItemBand9Frequency = new KConfigBaseEE::ItemDouble( currentGroup(), QStringLiteral( "band9Frequency" ), mBand9Frequency, 156.38 );
  itemBand9Frequency = new KConfigCompilerSignallingItem(innerItemBand9Frequency, this, notifyFunction, signalBand9FrequencyChanged);
  innerItemBand9Frequency->setMinValue(10);
  innerItemBand9Frequency->setMaxValue(24000);
  itemBand9Frequency->setWriteFlags(KConfigBase::Notify);
  itemBand9Frequency->setGroup(cgEqualizerinstanceIndexchannel);
  addItem( itemBand9Frequency, QStringLiteral( "band9Frequency" ) );
  KConfigCompilerSignallingItem  *itemBand10Frequency;
  KConfigBaseEE::ItemDouble  *innerItemBand10Frequency;
  innerItemBand10Frequency = new KConfigBaseEE::ItemDouble( currentGroup(), QStringLiteral( "band10Frequency" ), mBand10Frequency, 194.06 );
  itemBand10Frequency = new KConfigCompilerSignallingItem(innerItemBand10Frequency, this, notifyFunction, signalBand10FrequencyChanged);
  innerItemBand10Frequency->setMinValue(10);
  innerItemBand10Frequency->setMaxValue(24000);
  itemBand10Frequency->setWriteFlags(KConfigBase::Notify);
  itemBand10Frequency->setGroup(cgEqualizerinstanceIndexchannel);
  addItem( itemBand10Frequency, QStringLiteral( "band10Frequency" ) );
  KConfigCompilerSignallingItem  *itemBand11Frequency;
  KConfigBaseEE::ItemDouble  *innerItemBand11Frequency;
  innerItemBand11Frequency = new KConfigBaseEE::ItemDouble( currentGroup(), QStringLiteral( "band11Frequency" ), mBand11Frequency, 240.81 );
  itemBand11Frequency = new KConfigCompilerSignallingItem(innerItemBand11Frequency, this, notifyFunction, signalBand11FrequencyChanged);
  innerItemBand11Frequency->setMinValue(10);
  innerItemBand11Frequency->setMaxValue(24000);
  itemBand11Frequency->setWriteFlags(KConfigBase::Notify);
  itemBand11Frequency->setGroup(cgEqualizerinstanceIndexchannel);
  addItem( itemBand11Frequency, QStringLiteral( "band11Frequency" ) );
  KConfigCompilerSignallingItem  *itemBand12Frequency;
  KConfigBaseEE::ItemDouble  *innerItemBand12Frequency;
  innerItemBand12Frequency = new KConfigBaseEE::ItemDouble( currentGroup(), QStringLiteral( "band12Frequency" ), mBand12Frequency, 298.834 );
  itemBand12Frequency = new KConfigCompilerSignallingItem(innerItemBand12Frequency, this, notifyFunction, signalBand12FrequencyChanged);
  innerItemBand12Frequency->setMinValue(10);
  innerItemBand12Frequency->setMaxValue(24000);
  itemBand12Frequency->setWriteFlags(KConfigBase::Notify);
  itemBand12Frequency->setGroup(cgEqualizerinstanceIndexchannel);
  addItem( itemBand12Frequency, QStringLiteral( "band12Frequency" ) );
  KConfigCompilerSignallingItem  *itemBand13Frequency;
  KConfigBaseEE::ItemDouble  *innerItemBand13Frequency;
  innerItemBand13Frequency = new KConfigBaseEE::ItemDouble( currentGroup(), QStringLiteral( "band13Frequency" ), mBand13Frequency, 370.834 );
  itemBand13Frequency = new KConfigCompilerSignallingItem(innerItemBand13Frequency, this, notifyFunction, signalBand13FrequencyChanged);
  innerItemBand13Frequency->setMinValue(10);
  innerItemBand13Frequency->setMaxValue(24000);
  itemBand13Frequency->setWriteFlags(KConfigBase::Notify);
  itemBand13Frequency->setGroup(cgEqualizerinstanceIndexchannel);
  addItem( itemBand13Frequency, QStringLiteral( "band13Frequency" ) );
  KConfigCompilerSignallingItem  *itemBand14Frequency;
  KConfigBaseEE::ItemDouble  *innerItemBand14Frequency;
  innerItemBand14Frequency = new KConfigBaseEE::ItemDouble( currentGroup(), QStringLiteral( "band14Frequency" ), mBand14Frequency, 460.182 );
  itemBand14Frequency = new KConfigCompilerSignallingItem(innerItemBand14Frequency, this, notifyFunction, signalBand14FrequencyChanged);
  innerItemBand14Frequency->setMinValue(10);
  innerItemBand14Frequency->setMaxValue(24000);
  itemBand14Frequency->setWriteFlags(KConfigBase::Notify);
  itemBand14Frequency->setGroup(cgEqualizerinstanceIndexchannel);
  addItem( itemBand14Frequency, QStringLiteral( "band14Frequency" ) );
  KConfigCompilerSignallingItem  *itemBand15Frequency;
  KConfigBaseEE::ItemDouble  *innerItemBand15Frequency;
  innerItemBand15Frequency = new KConfigBaseEE::ItemDouble( currentGroup(), QStringLiteral( "band15Frequency" ), mBand15Frequency, 571.057 );
  itemBand15Frequency = new KConfigCompilerSignallingItem(innerItemBand15Frequency, this, notifyFunction, signalBand15FrequencyChanged);
  innerItemBand15Frequency->setMinValue(10);
  innerItemBand15Frequency->setMaxValue(24000);
  itemBand15Frequency->setWriteFlags(KConfigBase::Notify);
  itemBand15Frequency->setGroup(cgEqualizerinstanceIndexchannel);
  addItem( itemBand15Frequency, QStringLiteral( "band15Frequency" ) );
  KConfigCompilerSignallingItem  *itemBand16Frequency;
  KConfigBaseEE::ItemDouble  *innerItemBand16Frequency;
  innerItemBand16Frequency = new KConfigBaseEE::ItemDouble( currentGroup(), QStringLiteral( "band16Frequency" ), mBand16Frequency, 708.647 );
  itemBand16Frequency = new KConfigCompilerSignallingItem(innerItemBand16Frequency, this, notifyFunction, signalBand16FrequencyChanged);
  innerItemBand16Frequency->setMinValue(10);
  innerItemBand16Frequency->setMaxValue(24000);
  itemBand16Frequency->setWriteFlags(KConfigBase::Notify);
  itemBand16Frequency->setGroup(cgEqualizerinstanceIndexchannel);
  addItem( itemBand16Frequency, QStringLiteral( "band16Frequency" ) );
  KConfigCompilerSignallingItem  *itemBand17Frequency;
  KConfigBaseEE::ItemDouble  *innerItemBand17Frequency;
  innerItemBand17Frequency = new KConfigBaseEE::ItemDouble( currentGroup(), QStringLiteral( "band17Frequency" ), mBand17Frequency, 879.387 );
  itemBand17Frequency = new KConfigCompilerSignallingItem(innerItemBand17Frequency, this, notifyFunction, signalBand17FrequencyChanged);
  innerItemBand17Frequency->setMinValue(10);
  innerItemBand17Frequency->setMaxValue(24000);
  itemBand17Frequency->setWriteFlags(KConfigBase::Notify);
  itemBand17Frequency->setGroup(cgEqualizerinstanceIndexchannel);
  addItem( itemBand17Frequency, QStringLiteral( "band17Frequency" ) );
  KConfigCompilerSignallingItem  *itemBand18Frequency;
  KConfigBaseEE::ItemDouble  *innerItemBand18Frequency;
  innerItemBand18Frequency = new KConfigBaseEE::ItemDouble( currentGroup(), QStringLiteral( "band18Frequency" ), mBand18Frequency, 1091.26 );
  itemBand18Frequency = new KConfigCompilerSignallingItem(innerItemBand18Frequency, this, notifyFunction, signalBand18FrequencyChanged);
  innerItemBand18Frequency->setMinValue(10);
  innerItemBand18Frequency->setMaxValue(24000);
  itemBand18Frequency->setWriteFlags(KConfigBase::Notify);
  itemBand18Frequency->setGroup(cgEqualizerinstanceIndexchannel);
  addItem( itemBand18Frequency, QStringLiteral( "band18Frequency" ) );
  KConfigCompilerSignallingItem  *itemBand19Frequency;
  KConfigBaseEE::ItemDouble  *innerItemBand19Frequency;
  innerItemBand19Frequency = new KConfigBaseEE::ItemDouble( currentGroup(), QStringLiteral( "band19Frequency" ), mBand19Frequency, 1354.19 );
  itemBand19Frequency = new KConfigCompilerSignallingItem(innerItemBand19Frequency, this, notifyFunction, signalBand19FrequencyChanged);
  innerItemBand19Frequency->setMinValue(10);
  innerItemBand19Frequency->setMaxValue(24000);
  itemBand19Frequency->setWriteFlags(KConfigBase::Notify);
  itemBand19Frequency->setGroup(cgEqualizerinstanceIndexchannel);
  addItem( itemBand19Frequency, QStringLiteral( "band19Frequency" ) );
  KConfigCompilerSignallingItem  *itemBand20Frequency;
  KConfigBaseEE::ItemDouble  *innerItemBand20Frequency;
  innerItemBand20Frequency = new KConfigBaseEE::ItemDouble( currentGroup(), QStringLiteral( "band20Frequency" ), mBand20Frequency, 1680.47 );
  itemBand20Frequency = new KConfigCompilerSignallingItem(innerItemBand20Frequency, this, notifyFunction, signalBand20FrequencyChanged);
  innerItemBand20Frequency->setMinValue(10);
  innerItemBand20Frequency->setMaxValue(24000);
  itemBand20Frequency->setWriteFlags(KConfigBase::Notify);
  itemBand20Frequency->setGroup(cgEqualizerinstanceIndexchannel);
  addItem( itemBand20Frequency, QStringLiteral( "band20Frequency" ) );
  KConfigCompilerSignallingItem  *itemBand21Frequency;
  KConfigBaseEE::ItemDouble  *innerItemBand21Frequency;
  innerItemBand21Frequency = new KConfigBaseEE::ItemDouble( currentGroup(), QStringLiteral( "band21Frequency" ), mBand21Frequency, 2085.35 );
  itemBand21Frequency = new KConfigCompilerSignallingItem(innerItemBand21Frequency, this, notifyFunction, signalBand21FrequencyChanged);
  innerItemBand21Frequency->setMinValue(10);
  innerItemBand21Frequency->setMaxValue(24000);
  itemBand21Frequency->setWriteFlags(KConfigBase::Notify);
  itemBand21Frequency->setGroup(cgEqualizerinstanceIndexchannel);
  addItem( itemBand21Frequency, QStringLiteral( "band21Frequency" ) );
  KConfigCompilerSignallingItem  *itemBand22Frequency;
  KConfigBaseEE::ItemDouble  *innerItemBand22Frequency;
  innerItemBand22Frequency = new KConfigBaseEE::ItemDouble( currentGroup(), QStringLiteral( "band22Frequency" ), mBand22Frequency, 2587.79 );
  itemBand22Frequency = new KConfigCompilerSignallingItem(innerItemBand22Frequency, this, notifyFunction, signalBand22FrequencyChanged);
  innerItemBand22Frequency->setMinValue(10);
  innerItemBand22Frequency->setMaxValue(24000);
  itemBand22Frequency->setWriteFlags(KConfigBase::Notify);
  itemBand22Frequency->setGroup(cgEqualizerinstanceIndexchannel);
  addItem( itemBand22Frequency, QStringLiteral( "band22Frequency" ) );
  KConfigCompilerSignallingItem  *itemBand23Frequency;
  KConfigBaseEE::ItemDouble  *innerItemBand23Frequency;
  innerItemBand23Frequency = new KConfigBaseEE::ItemDouble( currentGroup(), QStringLiteral( "band23Frequency" ), mBand23Frequency, 3211.29 );
  itemBand23Frequency = new KConfigCompilerSignallingItem(innerItemBand23Frequency, this, notifyFunction, signalBand23FrequencyChanged);
  innerItemBand23Frequency->setMinValue(10);
  innerItemBand23Frequency->setMaxValue(24000);
  itemBand23Frequency->setWriteFlags(KConfigBase::Notify);
  itemBand23Frequency->setGroup(cgEqualizerinstanceIndexchannel);
  addItem( itemBand23Frequency, QStringLiteral( "band23Frequency" ) );
  KConfigCompilerSignallingItem  *itemBand24Frequency;
  KConfigBaseEE::ItemDouble  *innerItemBand24Frequency;
  innerItemBand24Frequency = new KConfigBaseEE::ItemDouble( currentGroup(), QStringLiteral( "band24Frequency" ), mBand24Frequency, 3985.01 );
  itemBand24Frequency = new KConfigCompilerSignallingItem(innerItemBand24Frequency, this, notifyFunction, signalBand24FrequencyChanged);
  innerItemBand24Frequency->setMinValue(10);
  innerItemBand24Frequency->setMaxValue(24000);
  itemBand24Frequency->setWriteFlags(KConfigBase::Notify);
  itemBand24Frequency->setGroup(cgEqualizerinstanceIndexchannel);
  addItem( itemBand24Frequency, QStringLiteral( "band24Frequency" ) );
  KConfigCompilerSignallingItem  *itemBand25Frequency;
  KConfigBaseEE::ItemDouble  *innerItemBand25Frequency;
  innerItemBand25Frequency = new KConfigBaseEE::ItemDouble( currentGroup(), QStringLiteral( "band25Frequency" ), mBand25Frequency, 4945.15 );
  itemBand25Frequency = new KConfigCompilerSignallingItem(innerItemBand25Frequency, this, notifyFunction, signalBand25FrequencyChanged);
  innerItemBand25Frequency->setMinValue(10);
  innerItemBand25Frequency->setMaxValue(24000);
  itemBand25Frequency->setWriteFlags(KConfigBase::Notify);
  itemBand25Frequency->setGroup(cgEqualizerinstanceIndexchannel);
  addItem( itemBand25Frequency, QStringLiteral( "band25Frequency" ) );
  KConfigCompilerSignallingItem  *itemBand26Frequency;
  KConfigBaseEE::ItemDouble  *innerItemBand26Frequency;
  innerItemBand26Frequency = new KConfigBaseEE::ItemDouble( currentGroup(), QStringLiteral( "band26Frequency" ), mBand26Frequency, 6136.63 );
  itemBand26Frequency = new KConfigCompilerSignallingItem(innerItemBand26Frequency, this, notifyFunction, signalBand26FrequencyChanged);
  innerItemBand26Frequency->setMinValue(10);
  innerItemBand26Frequency->setMaxValue(24000);
  itemBand26Frequency->setWriteFlags(KConfigBase::Notify);
  itemBand26Frequency->setGroup(cgEqualizerinstanceIndexchannel);
  addItem( itemBand26Frequency, QStringLiteral( "band26Frequency" ) );
  KConfigCompilerSignallingItem  *itemBand27Frequency;
  KConfigBaseEE::ItemDouble  *innerItemBand27Frequency;
  innerItemBand27Frequency = new KConfigBaseEE::ItemDouble( currentGroup(), QStringLiteral( "band27Frequency" ), mBand27Frequency, 7615.17 );
  itemBand27Frequency = new KConfigCompilerSignallingItem(innerItemBand27Frequency, this, notifyFunction, signalBand27FrequencyChanged);
  innerItemBand27Frequency->setMinValue(10);
  innerItemBand27Frequency->setMaxValue(24000);
  itemBand27Frequency->setWriteFlags(KConfigBase::Notify);
  itemBand27Frequency->setGroup(cgEqualizerinstanceIndexchannel);
  addItem( itemBand27Frequency, QStringLiteral( "band27Frequency" ) );
  KConfigCompilerSignallingItem  *itemBand28Frequency;
  KConfigBaseEE::ItemDouble  *innerItemBand28Frequency;
  innerItemBand28Frequency = new KConfigBaseEE::ItemDouble( currentGroup(), QStringLiteral( "band28Frequency" ), mBand28Frequency, 9449.96 );
  itemBand28Frequency = new KConfigCompilerSignallingItem(innerItemBand28Frequency, this, notifyFunction, signalBand28FrequencyChanged);
  innerItemBand28Frequency->setMinValue(10);
  innerItemBand28Frequency->setMaxValue(24000);
  itemBand28Frequency->setWriteFlags(KConfigBase::Notify);
  itemBand28Frequency->setGroup(cgEqualizerinstanceIndexchannel);
  addItem( itemBand28Frequency, QStringLiteral( "band28Frequency" ) );
  KConfigCompilerSignallingItem  *itemBand29Frequency;
  KConfigBaseEE::ItemDouble  *innerItemBand29Frequency;
  innerItemBand29Frequency = new KConfigBaseEE::ItemDouble( currentGroup(), QStringLiteral( "band29Frequency" ), mBand29Frequency, 11726.8 );
  itemBand29Frequency = new KConfigCompilerSignallingItem(innerItemBand29Frequency, this, notifyFunction, signalBand29FrequencyChanged);
  innerItemBand29Frequency->setMinValue(10);
  innerItemBand29Frequency->setMaxValue(24000);
  itemBand29Frequency->setWriteFlags(KConfigBase::Notify);
  itemBand29Frequency->setGroup(cgEqualizerinstanceIndexchannel);
  addItem( itemBand29Frequency, QStringLiteral( "band29Frequency" ) );
  KConfigCompilerSignallingItem  *itemBand30Frequency;
  KConfigBaseEE::ItemDouble  *innerItemBand30Frequency;
  innerItemBand30Frequency = new KConfigBaseEE::ItemDouble( currentGroup(), QStringLiteral( "band30Frequency" ), mBand30Frequency, 14552.2 );
  itemBand30Frequency = new KConfigCompilerSignallingItem(innerItemBand30Frequency, this, notifyFunction, signalBand30FrequencyChanged);
  innerItemBand30Frequency->setMinValue(10);
  innerItemBand30Frequency->setMaxValue(24000);
  itemBand30Frequency->setWriteFlags(KConfigBase::Notify);
  itemBand30Frequency->setGroup(cgEqualizerinstanceIndexchannel);
  addItem( itemBand30Frequency, QStringLiteral( "band30Frequency" ) );
  KConfigCompilerSignallingItem  *itemBand31Frequency;
  KConfigBaseEE::ItemDouble  *innerItemBand31Frequency;
  innerItemBand31Frequency = new KConfigBaseEE::ItemDouble( currentGroup(), QStringLiteral( "band31Frequency" ), mBand31Frequency, 18058.4 );
  itemBand31Frequency = new KConfigCompilerSignallingItem(innerItemBand31Frequency, this, notifyFunction, signalBand31FrequencyChanged);
  innerItemBand31Frequency->setMinValue(10);
  innerItemBand31Frequency->setMaxValue(24000);
  itemBand31Frequency->setWriteFlags(KConfigBase::Notify);
  itemBand31Frequency->setGroup(cgEqualizerinstanceIndexchannel);
  addItem( itemBand31Frequency, QStringLiteral( "band31Frequency" ) );
  KConfigCompilerSignallingItem  *itemBand0Q;
  KConfigBaseEE::ItemDouble  *innerItemBand0Q;
  innerItemBand0Q = new KConfigBaseEE::ItemDouble( currentGroup(), QStringLiteral( "band0Q" ), mBand0Q, 4.36 );
  itemBand0Q = new KConfigCompilerSignallingItem(innerItemBand0Q, this, notifyFunction, signalBand0QChanged);
  innerItemBand0Q->setMinValue(0);
  innerItemBand0Q->setMaxValue(100);
  itemBand0Q->setWriteFlags(KConfigBase::Notify);
  itemBand0Q->setGroup(cgEqualizerinstanceIndexchannel);
  addItem( itemBand0Q, QStringLiteral( "band0Q" ) );
  KConfigCompilerSignallingItem  *itemBand1Q;
  KConfigBaseEE::ItemDouble  *innerItemBand1Q;
  innerItemBand1Q = new KConfigBaseEE::ItemDouble( currentGroup(), QStringLiteral( "band1Q" ), mBand1Q, 4.36 );
  itemBand1Q = new KConfigCompilerSignallingItem(innerItemBand1Q, this, notifyFunction, signalBand1QChanged);
  innerItemBand1Q->setMinValue(0);
  innerItemBand1Q->setMaxValue(100);
  itemBand1Q->setWriteFlags(KConfigBase::Notify);
  itemBand1Q->setGroup(cgEqualizerinstanceIndexchannel);
  addItem( itemBand1Q, QStringLiteral( "band1Q" ) );
  KConfigCompilerSignallingItem  *itemBand2Q;
  KConfigBaseEE::ItemDouble  *innerItemBand2Q;
  innerItemBand2Q = new KConfigBaseEE::ItemDouble( currentGroup(), QStringLiteral( "band2Q" ), mBand2Q, 4.36 );
  itemBand2Q = new KConfigCompilerSignallingItem(innerItemBand2Q, this, notifyFunction, signalBand2QChanged);
  innerItemBand2Q->setMinValue(0);
  innerItemBand2Q->setMaxValue(100);
  itemBand2Q->setWriteFlags(KConfigBase::Notify);
  itemBand2Q->setGroup(cgEqualizerinstanceIndexchannel);
  addItem( itemBand2Q, QStringLiteral( "band2Q" ) );
  KConfigCompilerSignallingItem  *itemBand3Q;
  KConfigBaseEE::ItemDouble  *innerItemBand3Q;
  innerItemBand3Q = new KConfigBaseEE::ItemDouble( currentGroup(), QStringLiteral( "band3Q" ), mBand3Q, 4.36 );
  itemBand3Q = new KConfigCompilerSignallingItem(innerItemBand3Q, this, notifyFunction, signalBand3QChanged);
  innerItemBand3Q->setMinValue(0);
  innerItemBand3Q->setMaxValue(100);
  itemBand3Q->setWriteFlags(KConfigBase::Notify);
  itemBand3Q->setGroup(cgEqualizerinstanceIndexchannel);
  addItem( itemBand3Q, QStringLiteral( "band3Q" ) );
  KConfigCompilerSignallingItem  *itemBand4Q;
  KConfigBaseEE::ItemDouble  *innerItemBand4Q;
  innerItemBand4Q = new KConfigBaseEE::ItemDouble( currentGroup(), QStringLiteral( "band4Q" ), mBand4Q, 4.36 );
  itemBand4Q = new KConfigCompilerSignallingItem(innerItemBand4Q, this, notifyFunction, signalBand4QChanged);
  innerItemBand4Q->setMinValue(0);
  innerItemBand4Q->setMaxValue(100);
  itemBand4Q->setWriteFlags(KConfigBase::Notify);
  itemBand4Q->setGroup(cgEqualizerinstanceIndexchannel);
  addItem( itemBand4Q, QStringLiteral( "band4Q" ) );
  KConfigCompilerSignallingItem  *itemBand5Q;
  KConfigBaseEE::ItemDouble  *innerItemBand5Q;
  innerItemBand5Q = new KConfigBaseEE::ItemDouble( currentGroup(), QStringLiteral( "band5Q" ), mBand5Q, 4.36 );
  itemBand5Q = new KConfigCompilerSignallingItem(innerItemBand5Q, this, notifyFunction, signalBand5QChanged);
  innerItemBand5Q->setMinValue(0);
  innerItemBand5Q->setMaxValue(100);
  itemBand5Q->setWriteFlags(KConfigBase::Notify);
  itemBand5Q->setGroup(cgEqualizerinstanceIndexchannel);
  addItem( itemBand5Q, QStringLiteral( "band5Q" ) );
  KConfigCompilerSignallingItem  *itemBand6Q;
  KConfigBaseEE::ItemDouble  *innerItemBand6Q;
  innerItemBand6Q = new KConfigBaseEE::ItemDouble( currentGroup(), QStringLiteral( "band6Q" ), mBand6Q, 4.36 );
  itemBand6Q = new KConfigCompilerSignallingItem(innerItemBand6Q, this, notifyFunction, signalBand6QChanged);
  innerItemBand6Q->setMinValue(0);
  innerItemBand6Q->setMaxValue(100);
  itemBand6Q->setWriteFlags(KConfigBase::Notify);
  itemBand6Q->setGroup(cgEqualizerinstanceIndexchannel);
  addItem( itemBand6Q, QStringLiteral( "band6Q" ) );
  KConfigCompilerSignallingItem  *itemBand7Q;
  KConfigBaseEE::ItemDouble  *innerItemBand7Q;
  innerItemBand7Q = new KConfigBaseEE::ItemDouble( currentGroup(), QStringLiteral( "band7Q" ), mBand7Q, 4.36 );
  itemBand7Q = new KConfigCompilerSignallingItem(innerItemBand7Q, this, notifyFunction, signalBand7QChanged);
  innerItemBand7Q->setMinValue(0);
  innerItemBand7Q->setMaxValue(100);
  itemBand7Q->setWriteFlags(KConfigBase::Notify);
  itemBand7Q->setGroup(cgEqualizerinstanceIndexchannel);
  addItem( itemBand7Q, QStringLiteral( "band7Q" ) );
  KConfigCompilerSignallingItem  *itemBand8Q;
  KConfigBaseEE::ItemDouble  *innerItemBand8Q;
  innerItemBand8Q = new KConfigBaseEE::ItemDouble( currentGroup(), QStringLiteral( "band8Q" ), mBand8Q, 4.36 );
  itemBand8Q = new KConfigCompilerSignallingItem(innerItemBand8Q, this, notifyFunction, signalBand8QChanged);
  innerItemBand8Q->setMinValue(0);
  innerItemBand8Q->setMaxValue(100);
  itemBand8Q->setWriteFlags(KConfigBase::Notify);
  itemBand8Q->setGroup(cgEqualizerinstanceIndexchannel);
  addItem( itemBand8Q, QStringLiteral( "band8Q" ) );
  KConfigCompilerSignallingItem  *itemBand9Q;
  KConfigBaseEE::ItemDouble  *innerItemBand9Q;
  innerItemBand9Q = new KConfigBaseEE::ItemDouble( currentGroup(), QStringLiteral( "band9Q" ), mBand9Q, 4.36 );
  itemBand9Q = new KConfigCompilerSignallingItem(innerItemBand9Q, this, notifyFunction, signalBand9QChanged);
  innerItemBand9Q->setMinValue(0);
  innerItemBand9Q->setMaxValue(100);
  itemBand9Q->setWriteFlags(KConfigBase::Notify);
  itemBand9Q->setGroup(cgEqualizerinstanceIndexchannel);
  addItem( itemBand9Q, QStringLiteral( "band9Q" ) );
  KConfigCompilerSignallingItem  *itemBand10Q;
  KConfigBaseEE::ItemDouble  *innerItemBand10Q;
  innerItemBand10Q = new KConfigBaseEE::ItemDouble( currentGroup(), QStringLiteral( "band10Q" ), mBand10Q, 4.36 );
  itemBand10Q = new KConfigCompilerSignallingItem(innerItemBand10Q, this, notifyFunction, signalBand10QChanged);
  innerItemBand10Q->setMinValue(0);
  innerItemBand10Q->setMaxValue(100);
  itemBand10Q->setWriteFlags(KConfigBase::Notify);
  itemBand10Q->setGroup(cgEqualizerinstanceIndexchannel);
  addItem( itemBand10Q, QStringLiteral( "band10Q" ) );
  KConfigCompilerSignallingItem  *itemBand11Q;
  KConfigBaseEE::ItemDouble  *innerItemBand11Q;
  innerItemBand11Q = new KConfigBaseEE::ItemDouble( currentGroup(), QStringLiteral( "band11Q" ), mBand11Q, 4.36 );
  itemBand11Q = new KConfigCompilerSignallingItem(innerItemBand11Q, this, notifyFunction, signalBand11QChanged);
  innerItemBand11Q->setMinValue(0);
  innerItemBand11Q->setMaxValue(100);
  itemBand11Q->setWriteFlags(KConfigBase::Notify);
  itemBand11Q->setGroup(cgEqualizerinstanceIndexchannel);
  addItem( itemBand11Q, QStringLiteral( "band11Q" ) );
  KConfigCompilerSignallingItem  *itemBand12Q;
  KConfigBaseEE::ItemDouble  *innerItemBand12Q;
  innerItemBand12Q = new KConfigBaseEE::ItemDouble( currentGroup(), QStringLiteral( "band12Q" ), mBand12Q, 4.36 );
  itemBand12Q = new KConfigCompilerSignallingItem(innerItemBand12Q, this, notifyFunction, signalBand12QChanged);
  innerItemBand12Q->setMinValue(0);
  innerItemBand12Q->setMaxValue(100);
  itemBand12Q->setWriteFlags(KConfigBase::Notify);
  itemBand12Q->setGroup(cgEqualizerinstanceIndexchannel);
  addItem( itemBand12Q, QStringLiteral( "band12Q" ) );
  KConfigCompilerSignallingItem  *itemBand13Q;
  KConfigBaseEE::ItemDouble  *innerItemBand13Q;
  innerItemBand13Q = new KConfigBaseEE::ItemDouble( currentGroup(), QStringLiteral( "band13Q" ), mBand13Q, 4.36 );
  itemBand13Q = new KConfigCompilerSignallingItem(innerItemBand13Q, this, notifyFunction, signalBand13QChanged);
  innerItemBand13Q->setMinValue(0);
  innerItemBand13Q->setMaxValue(100);
  itemBand13Q->setWriteFlags(KConfigBase::Notify);
  itemBand13Q->setGroup(cgEqualizerinstanceIndexchannel);
  addItem( itemBand13Q, QStringLiteral( "band13Q" ) );
  KConfigCompilerSignallingItem  *itemBand14Q;
  KConfigBaseEE::ItemDouble  *innerItemBand14Q;
  innerItemBand14Q = new KConfigBaseEE::ItemDouble( currentGroup(), QStringLiteral( "band14Q" ), mBand14Q, 4.36 );
  itemBand14Q = new KConfigCompilerSignallingItem(innerItemBand14Q, this, notifyFunction, signalBand14QChanged);
  innerItemBand14Q->setMinValue(0);
  innerItemBand14Q->setMaxValue(100);
  itemBand14Q->setWriteFlags(KConfigBase::Notify);
  itemBand14Q->setGroup(cgEqualizerinstanceIndexchannel);
  addItem( itemBand14Q, QStringLiteral( "band14Q" ) );
  KConfigCompilerSignallingItem  *itemBand15Q;
  KConfigBaseEE::ItemDouble  *innerItemBand15Q;
  innerItemBand15Q = new KConfigBaseEE::ItemDouble( currentGroup(), QStringLiteral( "band15Q" ), mBand15Q, 4.36 );
  itemBand15Q = new KConfigCompilerSignallingItem(innerItemBand15Q, this, notifyFunction, signalBand15QChanged);
  innerItemBand15Q->setMinValue(0);
  innerItemBand15Q->setMaxValue(100);
  itemBand15Q->setWriteFlags(KConfigBase::Notify);
  itemBand15Q->setGroup(cgEqualizerinstanceIndexchannel);
  addItem( itemBand15Q, QStringLiteral( "band15Q" ) );
  KConfigCompilerSignallingItem  *itemBand16Q;
  KConfigBaseEE::ItemDouble  *innerItemBand16Q;
  innerItemBand16Q = new KConfigBaseEE::ItemDouble( currentGroup(), QStringLiteral( "band16Q" ), mBand16Q, 4.36 );
  itemBand16Q = new KConfigCompilerSignallingItem(innerItemBand16Q, this, notifyFunction, signalBand16QChanged);
  innerItemBand16Q->setMinValue(0);
  innerItemBand16Q->setMaxValue(100);
  itemBand16Q->setWriteFlags(KConfigBase::Notify);
  itemBand16Q->setGroup(cgEqualizerinstanceIndexchannel);
  addItem( itemBand16Q, QStringLiteral( "band16Q" ) );
  KConfigCompilerSignallingItem  *itemBand17Q;
  KConfigBaseEE::ItemDouble  *innerItemBand17Q;
  innerItemBand17Q = new KConfigBaseEE::ItemDouble( currentGroup(), QStringLiteral( "band17Q" ), mBand17Q, 4.36 );
  itemBand17Q = new KConfigCompilerSignallingItem(innerItemBand17Q, this, notifyFunction, signalBand17QChanged);
  innerItemBand17Q->setMinValue(0);
  innerItemBand17Q->setMaxValue(100);
  itemBand17Q->setWriteFlags(KConfigBase::Notify);
  itemBand17Q->setGroup(cgEqualizerinstanceIndexchannel);
  addItem( itemBand17Q, QStringLiteral( "band17Q" ) );
  KConfigCompilerSignallingItem  *itemBand18Q;
  KConfigBaseEE::ItemDouble  *innerItemBand18Q;
  innerItemBand18Q = new KConfigBaseEE::ItemDouble( currentGroup(), QStringLiteral( "band18Q" ), mBand18Q, 4.36 );
  itemBand18Q = new KConfigCompilerSignallingItem(innerItemBand18Q, this, notifyFunction, signalBand18QChanged);
  innerItemBand18Q->setMinValue(0);
  innerItemBand18Q->setMaxValue(100);
  itemBand18Q->setWriteFlags(KConfigBase::Notify);
  itemBand18Q->setGroup(cgEqualizerinstanceIndexchannel);
  addItem( itemBand18Q, QStringLiteral( "band18Q" ) );
  KConfigCompilerSignallingItem  *itemBand19Q;
  KConfigBaseEE::ItemDouble  *innerItemBand19Q;
  innerItemBand19Q = new KConfigBaseEE::ItemDouble( currentGroup(), QStringLiteral( "band19Q" ), mBand19Q, 4.36 );
  itemBand19Q = new KConfigCompilerSignallingItem(innerItemBand19Q, this, notifyFunction, signalBand19QChanged);
  innerItemBand19Q->setMinValue(0);
  innerItemBand19Q->setMaxValue(100);
  itemBand19Q->setWriteFlags(KConfigBase::Notify);
  itemBand19Q->setGroup(cgEqualizerinstanceIndexchannel);
  addItem( itemBand19Q, QStringLiteral( "band19Q" ) );
  KConfigCompilerSignallingItem  *itemBand20Q;
  KConfigBaseEE::ItemDouble  *innerItemBand20Q;
  innerItemBand20Q = new KConfigBaseEE::ItemDouble( currentGroup(), QStringLiteral( "band20Q" ), mBand20Q, 4.36 );
  itemBand20Q = new KConfigCompilerSignallingItem(innerItemBand20Q, this, notifyFunction, signalBand20QChanged);
  innerItemBand20Q->setMinValue(0);
  innerItemBand20Q->setMaxValue(100);
  itemBand20Q->setWriteFlags(KConfigBase::Notify);
  itemBand20Q->setGroup(cgEqualizerinstanceIndexchannel);
  addItem( itemBand20Q, QStringLiteral( "band20Q" ) );
  KConfigCompilerSignallingItem  *itemBand21Q;
  KConfigBaseEE::ItemDouble  *innerItemBand21Q;
  innerItemBand21Q = new KConfigBaseEE::ItemDouble( currentGroup(), QStringLiteral( "band21Q" ), mBand21Q, 4.36 );
  itemBand21Q = new KConfigCompilerSignallingItem(innerItemBand21Q, this, notifyFunction, signalBand21QChanged);
  innerItemBand21Q->setMinValue(0);
  innerItemBand21Q->setMaxValue(100);
  itemBand21Q->setWriteFlags(KConfigBase::Notify);
  itemBand21Q->setGroup(cgEqualizerinstanceIndexchannel);
  addItem( itemBand21Q, QStringLiteral( "band21Q" ) );
  KConfigCompilerSignallingItem  *itemBand22Q;
  KConfigBaseEE::ItemDouble  *innerItemBand22Q;
  innerItemBand22Q = new KConfigBaseEE::ItemDouble( currentGroup(), QStringLiteral( "band22Q" ), mBand22Q, 4.36 );
  itemBand22Q = new KConfigCompilerSignallingItem(innerItemBand22Q, this, notifyFunction, signalBand22QChanged);
  innerItemBand22Q->setMinValue(0);
  innerItemBand22Q->setMaxValue(100);
  itemBand22Q->setWriteFlags(KConfigBase::Notify);
  itemBand22Q->setGroup(cgEqualizerinstanceIndexchannel);
  addItem( itemBand22Q, QStringLiteral( "band22Q" ) );
  KConfigCompilerSignallingItem  *itemBand23Q;
  KConfigBaseEE::ItemDouble  *innerItemBand23Q;
  innerItemBand23Q = new KConfigBaseEE::ItemDouble( currentGroup(), QStringLiteral( "band23Q" ), mBand23Q, 4.36 );
  itemBand23Q = new KConfigCompilerSignallingItem(innerItemBand23Q, this, notifyFunction, signalBand23QChanged);
  innerItemBand23Q->setMinValue(0);
  innerItemBand23Q->setMaxValue(100);
  itemBand23Q->setWriteFlags(KConfigBase::Notify);
  itemBand23Q->setGroup(cgEqualizerinstanceIndexchannel);
  addItem( itemBand23Q, QStringLiteral( "band23Q" ) );
  KConfigCompilerSignallingItem  *itemBand24Q;
  KConfigBaseEE::ItemDouble  *innerItemBand24Q;
  innerItemBand24Q = new KConfigBaseEE::ItemDouble( currentGroup(), QStringLiteral( "band24Q" ), mBand24Q, 4.36 );
  itemBand24Q = new KConfigCompilerSignallingItem(innerItemBand24Q, this, notifyFunction, signalBand24QChanged);
  innerItemBand24Q->setMinValue(0);
  innerItemBand24Q->setMaxValue(100);
  itemBand24Q->setWriteFlags(KConfigBase::Notify);
  itemBand24Q->setGroup(cgEqualizerinstanceIndexchannel);
  addItem( itemBand24Q, QStringLiteral( "band24Q" ) );
  KConfigCompilerSignallingItem  *itemBand25Q;
  KConfigBaseEE::ItemDouble  *innerItemBand25Q;
  innerItemBand25Q = new KConfigBaseEE::ItemDouble( currentGroup(), QStringLiteral( "band25Q" ), mBand25Q, 4.36 );
  itemBand25Q = new KConfigCompilerSignallingItem(innerItemBand25Q, this, notifyFunction, signalBand25QChanged);
  innerItemBand25Q->setMinValue(0);
  innerItemBand25Q->setMaxValue(100);
  itemBand25Q->setWriteFlags(KConfigBase::Notify);
  itemBand25Q->setGroup(cgEqualizerinstanceIndexchannel);
  addItem( itemBand25Q, QStringLiteral( "band25Q" ) );
  KConfigCompilerSignallingItem  *itemBand26Q;
  KConfigBaseEE::ItemDouble  *innerItemBand26Q;
  innerItemBand26Q = new KConfigBaseEE::ItemDouble( currentGroup(), QStringLiteral( "band26Q" ), mBand26Q, 4.36 );
  itemBand26Q = new KConfigCompilerSignallingItem(innerItemBand26Q, this, notifyFunction, signalBand26QChanged);
  innerItemBand26Q->setMinValue(0);
  innerItemBand26Q->setMaxValue(100);
  itemBand26Q->setWriteFlags(KConfigBase::Notify);
  itemBand26Q->setGroup(cgEqualizerinstanceIndexchannel);
  addItem( itemBand26Q, QStringLiteral( "band26Q" ) );
  KConfigCompilerSignallingItem  *itemBand27Q;
  KConfigBaseEE::ItemDouble  *innerItemBand27Q;
  innerItemBand27Q = new KConfigBaseEE::ItemDouble( currentGroup(), QStringLiteral( "band27Q" ), mBand27Q, 4.36 );
  itemBand27Q = new KConfigCompilerSignallingItem(innerItemBand27Q, this, notifyFunction, signalBand27QChanged);
  innerItemBand27Q->setMinValue(0);
  innerItemBand27Q->setMaxValue(100);
  itemBand27Q->setWriteFlags(KConfigBase::Notify);
  itemBand27Q->setGroup(cgEqualizerinstanceIndexchannel);
  addItem( itemBand27Q, QStringLiteral( "band27Q" ) );
  KConfigCompilerSignallingItem  *itemBand28Q;
  KConfigBaseEE::ItemDouble  *innerItemBand28Q;
  innerItemBand28Q = new KConfigBaseEE::ItemDouble( currentGroup(), QStringLiteral( "band28Q" ), mBand28Q, 4.36 );
  itemBand28Q = new KConfigCompilerSignallingItem(innerItemBand28Q, this, notifyFunction, signalBand28QChanged);
  innerItemBand28Q->setMinValue(0);
  innerItemBand28Q->setMaxValue(100);
  itemBand28Q->setWriteFlags(KConfigBase::Notify);
  itemBand28Q->setGroup(cgEqualizerinstanceIndexchannel);
  addItem( itemBand28Q, QStringLiteral( "band28Q" ) );
  KConfigCompilerSignallingItem  *itemBand29Q;
  KConfigBaseEE::ItemDouble  *innerItemBand29Q;
  innerItemBand29Q = new KConfigBaseEE::ItemDouble( currentGroup(), QStringLiteral( "band29Q" ), mBand29Q, 4.36 );
  itemBand29Q = new KConfigCompilerSignallingItem(innerItemBand29Q, this, notifyFunction, signalBand29QChanged);
  innerItemBand29Q->setMinValue(0);
  innerItemBand29Q->setMaxValue(100);
  itemBand29Q->setWriteFlags(KConfigBase::Notify);
  itemBand29Q->setGroup(cgEqualizerinstanceIndexchannel);
  addItem( itemBand29Q, QStringLiteral( "band29Q" ) );
  KConfigCompilerSignallingItem  *itemBand30Q;
  KConfigBaseEE::ItemDouble  *innerItemBand30Q;
  innerItemBand30Q = new KConfigBaseEE::ItemDouble( currentGroup(), QStringLiteral( "band30Q" ), mBand30Q, 4.36 );
  itemBand30Q = new KConfigCompilerSignallingItem(innerItemBand30Q, this, notifyFunction, signalBand30QChanged);
  innerItemBand30Q->setMinValue(0);
  innerItemBand30Q->setMaxValue(100);
  itemBand30Q->setWriteFlags(KConfigBase::Notify);
  itemBand30Q->setGroup(cgEqualizerinstanceIndexchannel);
  addItem( itemBand30Q, QStringLiteral( "band30Q" ) );
  KConfigCompilerSignallingItem  *itemBand31Q;
  KConfigBaseEE::ItemDouble  *innerItemBand31Q;
  innerItemBand31Q = new KConfigBaseEE::ItemDouble( currentGroup(), QStringLiteral( "band31Q" ), mBand31Q, 4.36 );
  itemBand31Q = new KConfigCompilerSignallingItem(innerItemBand31Q, this, notifyFunction, signalBand31QChanged);
  innerItemBand31Q->setMinValue(0);
  innerItemBand31Q->setMaxValue(100);
  itemBand31Q->setWriteFlags(KConfigBase::Notify);
  itemBand31Q->setGroup(cgEqualizerinstanceIndexchannel);
  addItem( itemBand31Q, QStringLiteral( "band31Q" ) );
  KConfigCompilerSignallingItem  *itemBand0Width;
  KConfigBaseEE::ItemDouble  *innerItemBand0Width;
  innerItemBand0Width = new KConfigBaseEE::ItemDouble( currentGroup(), QStringLiteral( "band0Width" ), mBand0Width, 4 );
  itemBand0Width = new KConfigCompilerSignallingItem(innerItemBand0Width, this, notifyFunction, signalBand0WidthChanged);
  innerItemBand0Width->setMinValue(0);
  innerItemBand0Width->setMaxValue(12);
  itemBand0Width->setWriteFlags(KConfigBase::Notify);
  itemBand0Width->setGroup(cgEqualizerinstanceIndexchannel);
  addItem( itemBand0Width, QStringLiteral( "band0Width" ) );
  KConfigCompilerSignallingItem  *itemBand1Width;
  KConfigBaseEE::ItemDouble  *innerItemBand1Width;
  innerItemBand1Width = new KConfigBaseEE::ItemDouble( currentGroup(), QStringLiteral( "band1Width" ), mBand1Width, 4 );
  itemBand1Width = new KConfigCompilerSignallingItem(innerItemBand1Width, this, notifyFunction, signalBand1WidthChanged);
  innerItemBand1Width->setMinValue(0);
  innerItemBand1Width->setMaxValue(12);
  itemBand1Width->setWriteFlags(KConfigBase::Notify);
  itemBand1Width->setGroup(cgEqualizerinstanceIndexchannel);
  addItem( itemBand1Width, QStringLiteral( "band1Width" ) );
  KConfigCompilerSignallingItem  *itemBand2Width;
  KConfigBaseEE::ItemDouble  *innerItemBand2Width;
  innerItemBand2Width = new KConfigBaseEE::ItemDouble( currentGroup(), QStringLiteral( "band2Width" ), mBand2Width, 4 );
  itemBand2Width = new KConfigCompilerSignallingItem(innerItemBand2Width, this, notifyFunction, signalBand2WidthChanged);
  innerItemBand2Width->setMinValue(0);
  innerItemBand2Width->setMaxValue(12);
  itemBand2Width->setWriteFlags(KConfigBase::Notify);
  itemBand2Width->setGroup(cgEqualizerinstanceIndexchannel);
  addItem( itemBand2Width, QStringLiteral( "band2Width" ) );
  KConfigCompilerSignallingItem  *itemBand3Width;
  KConfigBaseEE::ItemDouble  *innerItemBand3Width;
  innerItemBand3Width = new KConfigBaseEE::ItemDouble( currentGroup(), QStringLiteral( "band3Width" ), mBand3Width, 4 );
  itemBand3Width = new KConfigCompilerSignallingItem(innerItemBand3Width, this, notifyFunction, signalBand3WidthChanged);
  innerItemBand3Width->setMinValue(0);
  innerItemBand3Width->setMaxValue(12);
  itemBand3Width->setWriteFlags(KConfigBase::Notify);
  itemBand3Width->setGroup(cgEqualizerinstanceIndexchannel);
  addItem( itemBand3Width, QStringLiteral( "band3Width" ) );
  KConfigCompilerSignallingItem  *itemBand4Width;
  KConfigBaseEE::ItemDouble  *innerItemBand4Width;
  innerItemBand4Width = new KConfigBaseEE::ItemDouble( currentGroup(), QStringLiteral( "band4Width" ), mBand4Width, 4 );
  itemBand4Width = new KConfigCompilerSignallingItem(innerItemBand4Width, this, notifyFunction, signalBand4WidthChanged);
  innerItemBand4Width->setMinValue(0);
  innerItemBand4Width->setMaxValue(12);
  itemBand4Width->setWriteFlags(KConfigBase::Notify);
  itemBand4Width->setGroup(cgEqualizerinstanceIndexchannel);
  addItem( itemBand4Width, QStringLiteral( "band4Width" ) );
  KConfigCompilerSignallingItem  *itemBand5Width;
  KConfigBaseEE::ItemDouble  *innerItemBand5Width;
  innerItemBand5Width = new KConfigBaseEE::ItemDouble( currentGroup(), QStringLiteral( "band5Width" ), mBand5Width, 4 );
  itemBand5Width = new KConfigCompilerSignallingItem(innerItemBand5Width, this, notifyFunction, signalBand5WidthChanged);
  innerItemBand5Width->setMinValue(0);
  innerItemBand5Width->setMaxValue(12);
  itemBand5Width->setWriteFlags(KConfigBase::Notify);
  itemBand5Width->setGroup(cgEqualizerinstanceIndexchannel);
  addItem( itemBand5Width, QStringLiteral( "band5Width" ) );
  KConfigCompilerSignallingItem  *itemBand6Width;
  KConfigBaseEE::ItemDouble  *innerItemBand6Width;
  innerItemBand6Width = new KConfigBaseEE::ItemDouble( currentGroup(), QStringLiteral( "band6Width" ), mBand6Width, 4 );
  itemBand6Width = new KConfigCompilerSignallingItem(innerItemBand6Width, this, notifyFunction, signalBand6WidthChanged);
  innerItemBand6Width->setMinValue(0);
  innerItemBand6Width->setMaxValue(12);
  itemBand6Width->setWriteFlags(KConfigBase::Notify);
  itemBand6Width->setGroup(cgEqualizerinstanceIndexchannel);
  addItem( itemBand6Width, QStringLiteral( "band6Width" ) );
  KConfigCompilerSignallingItem  *itemBand7Width;
  KConfigBaseEE::ItemDouble  *innerItemBand7Width;
  innerItemBand7Width = new KConfigBaseEE::ItemDouble( currentGroup(), QStringLiteral( "band7Width" ), mBand7Width, 4 );
  itemBand7Width = new KConfigCompilerSignallingItem(innerItemBand7Width, this, notifyFunction, signalBand7WidthChanged);
  innerItemBand7Width->setMinValue(0);
  innerItemBand7Width->setMaxValue(12);
  itemBand7Width->setWriteFlags(KConfigBase::Notify);
  itemBand7Width->setGroup(cgEqualizerinstanceIndexchannel);
  addItem( itemBand7Width, QStringLiteral( "band7Width" ) );
  KConfigCompilerSignallingItem  *itemBand8Width;
  KConfigBaseEE::ItemDouble  *innerItemBand8Width;
  innerItemBand8Width = new KConfigBaseEE::ItemDouble( currentGroup(), QStringLiteral( "band8Width" ), mBand8Width, 4 );
  itemBand8Width = new KConfigCompilerSignallingItem(innerItemBand8Width, this, notifyFunction, signalBand8WidthChanged);
  innerItemBand8Width->setMinValue(0);
  innerItemBand8Width->setMaxValue(12);
  itemBand8Width->setWriteFlags(KConfigBase::Notify);
  itemBand8Width->setGroup(cgEqualizerinstanceIndexchannel);
  addItem( itemBand8Width, QStringLiteral( "band8Width" ) );
  KConfigCompilerSignallingItem  *itemBand9Width;
  KConfigBaseEE::ItemDouble  *innerItemBand9Width;
  innerItemBand9Width = new KConfigBaseEE::ItemDouble( currentGroup(), QStringLiteral( "band9Width" ), mBand9Width, 4 );
  itemBand9Width = new KConfigCompilerSignallingItem(innerItemBand9Width, this, notifyFunction, signalBand9WidthChanged);
  innerItemBand9Width->setMinValue(0);
  innerItemBand9Width->setMaxValue(12);
  itemBand9Width->setWriteFlags(KConfigBase::Notify);
  itemBand9Width->setGroup(cgEqualizerinstanceIndexchannel);
  addItem( itemBand9Width, QStringLiteral( "band9Width" ) );
  KConfigCompilerSignallingItem  *itemBand10Width;
  KConfigBaseEE::ItemDouble  *innerItemBand10Width;
  innerItemBand10Width = new KConfigBaseEE::ItemDouble( currentGroup(), QStringLiteral( "band10Width" ), mBand10Width, 4 );
  itemBand10Width = new KConfigCompilerSignallingItem(innerItemBand10Width, this, notifyFunction, signalBand10WidthChanged);
  innerItemBand10Width->setMinValue(0);
  innerItemBand10Width->setMaxValue(12);
  itemBand10Width->setWriteFlags(KConfigBase::Notify);
  itemBand10Width->setGroup(cgEqualizerinstanceIndexchannel);
  addItem( itemBand10Width, QStringLiteral( "band10Width" ) );
  KConfigCompilerSignallingItem  *itemBand11Width;
  KConfigBaseEE::ItemDouble  *innerItemBand11Width;
  innerItemBand11Width = new KConfigBaseEE::ItemDouble( currentGroup(), QStringLiteral( "band11Width" ), mBand11Width, 4 );
  itemBand11Width = new KConfigCompilerSignallingItem(innerItemBand11Width, this, notifyFunction, signalBand11WidthChanged);
  innerItemBand11Width->setMinValue(0);
  innerItemBand11Width->setMaxValue(12);
  itemBand11Width->setWriteFlags(KConfigBase::Notify);
  itemBand11Width->setGroup(cgEqualizerinstanceIndexchannel);
  addItem( itemBand11Width, QStringLiteral( "band11Width" ) );
  KConfigCompilerSignallingItem  *itemBand12Width;
  KConfigBaseEE::ItemDouble  *innerItemBand12Width;
  innerItemBand12Width = new KConfigBaseEE::ItemDouble( currentGroup(), QStringLiteral( "band12Width" ), mBand12Width, 4 );
  itemBand12Width = new KConfigCompilerSignallingItem(innerItemBand12Width, this, notifyFunction, signalBand12WidthChanged);
  innerItemBand12Width->setMinValue(0);
  innerItemBand12Width->setMaxValue(12);
  itemBand12Width->setWriteFlags(KConfigBase::Notify);
  itemBand12Width->setGroup(cgEqualizerinstanceIndexchannel);
  addItem( itemBand12Width, QStringLiteral( "band12Width" ) );
  KConfigCompilerSignallingItem  *itemBand13Width;
  KConfigBaseEE::ItemDouble  *innerItemBand13Width;
  innerItemBand13Width = new KConfigBaseEE::ItemDouble( currentGroup(), QStringLiteral( "band13Width" ), mBand13Width, 4 );
  itemBand13Width = new KConfigCompilerSignallingItem(innerItemBand13Width, this, notifyFunction, signalBand13WidthChanged);
  innerItemBand13Width->setMinValue(0);
  innerItemBand13Width->setMaxValue(12);
  itemBand13Width->setWriteFlags(KConfigBase::Notify);
  itemBand13Width->setGroup(cgEqualizerinstanceIndexchannel);
  addItem( itemBand13Width, QStringLiteral( "band13Width" ) );
  KConfigCompilerSignallingItem  *itemBand14Width;
  KConfigBaseEE::ItemDouble  *innerItemBand14Width;
  innerItemBand14Width = new KConfigBaseEE::ItemDouble( currentGroup(), QStringLiteral( "band14Width" ), mBand14Width, 4 );
  itemBand14Width = new KConfigCompilerSignallingItem(innerItemBand14Width, this, notifyFunction, signalBand14WidthChanged);
  innerItemBand14Width->setMinValue(0);
  innerItemBand14Width->setMaxValue(12);
  itemBand14Width->setWriteFlags(KConfigBase::Notify);
  itemBand14Width->setGroup(cgEqualizerinstanceIndexchannel);
  addItem( itemBand14Width, QStringLiteral( "band14Width" ) );
  KConfigCompilerSignallingItem  *itemBand15Width;
  KConfigBaseEE::ItemDouble  *innerItemBand15Width;
  innerItemBand15Width = new KConfigBaseEE::ItemDouble( currentGroup(), QStringLiteral( "band15Width" ), mBand15Width, 4 );
  itemBand15Width = new KConfigCompilerSignallingItem(innerItemBand15Width, this, notifyFunction, signalBand15WidthChanged);
  innerItemBand15Width->setMinValue(0);
  innerItemBand15Width->setMaxValue(12);
  itemBand15Width->setWriteFlags(KConfigBase::Notify);
  itemBand15Width->setGroup(cgEqualizerinstanceIndexchannel);
  addItem( itemBand15Width, QStringLiteral( "band15Width" ) );
  KConfigCompilerSignallingItem  *itemBand16Width;
  KConfigBaseEE::ItemDouble  *innerItemBand16Width;
  innerItemBand16Width = new KConfigBaseEE::ItemDouble( currentGroup(), QStringLiteral( "band16Width" ), mBand16Width, 4 );
  itemBand16Width = new KConfigCompilerSignallingItem(innerItemBand16Width, this, notifyFunction, signalBand16WidthChanged);
  innerItemBand16Width->setMinValue(0);
  innerItemBand16Width->setMaxValue(12);
  itemBand16Width->setWriteFlags(KConfigBase::Notify);
  itemBand16Width->setGroup(cgEqualizerinstanceIndexchannel);
  addItem( itemBand16Width, QStringLiteral( "band16Width" ) );
  KConfigCompilerSignallingItem  *itemBand17Width;
  KConfigBaseEE::ItemDouble  *innerItemBand17Width;
  innerItemBand17Width = new KConfigBaseEE::ItemDouble( currentGroup(), QStringLiteral( "band17Width" ), mBand17Width, 4 );
  itemBand17Width = new KConfigCompilerSignallingItem(innerItemBand17Width, this, notifyFunction, signalBand17WidthChanged);
  innerItemBand17Width->setMinValue(0);
  innerItemBand17Width->setMaxValue(12);
  itemBand17Width->setWriteFlags(KConfigBase::Notify);
  itemBand17Width->setGroup(cgEqualizerinstanceIndexchannel);
  addItem( itemBand17Width, QStringLiteral( "band17Width" ) );
  KConfigCompilerSignallingItem  *itemBand18Width;
  KConfigBaseEE::ItemDouble  *innerItemBand18Width;
  innerItemBand18Width = new KConfigBaseEE::ItemDouble( currentGroup(), QStringLiteral( "band18Width" ), mBand18Width, 4 );
  itemBand18Width = new KConfigCompilerSignallingItem(innerItemBand18Width, this, notifyFunction, signalBand18WidthChanged);
  innerItemBand18Width->setMinValue(0);
  innerItemBand18Width->setMaxValue(12);
  itemBand18Width->setWriteFlags(KConfigBase::Notify);
  itemBand18Width->setGroup(cgEqualizerinstanceIndexchannel);
  addItem( itemBand18Width, QStringLiteral( "band18Width" ) );
  KConfigCompilerSignallingItem  *itemBand19Width;
  KConfigBaseEE::ItemDouble  *innerItemBand19Width;
  innerItemBand19Width = new KConfigBaseEE::ItemDouble( currentGroup(), QStringLiteral( "band19Width" ), mBand19Width, 4 );
  itemBand19Width = new KConfigCompilerSignallingItem(innerItemBand19Width, this, notifyFunction, signalBand19WidthChanged);
  innerItemBand19Width->setMinValue(0);
  innerItemBand19Width->setMaxValue(12);
  itemBand19Width->setWriteFlags(KConfigBase::Notify);
  itemBand19Width->setGroup(cgEqualizerinstanceIndexchannel);
  addItem( itemBand19Width, QStringLiteral( "band19Width" ) );
  KConfigCompilerSignallingItem  *itemBand20Width;
  KConfigBaseEE::ItemDouble  *innerItemBand20Width;
  innerItemBand20Width = new KConfigBaseEE::ItemDouble( currentGroup(), QStringLiteral( "band20Width" ), mBand20Width, 4 );
  itemBand20Width = new KConfigCompilerSignallingItem(innerItemBand20Width, this, notifyFunction, signalBand20WidthChanged);
  innerItemBand20Width->setMinValue(0);
  innerItemBand20Width->setMaxValue(12);
  itemBand20Width->setWriteFlags(KConfigBase::Notify);
  itemBand20Width->setGroup(cgEqualizerinstanceIndexchannel);
  addItem( itemBand20Width, QStringLiteral( "band20Width" ) );
  KConfigCompilerSignallingItem  *itemBand21Width;
  KConfigBaseEE::ItemDouble  *innerItemBand21Width;
  innerItemBand21Width = new KConfigBaseEE::ItemDouble( currentGroup(), QStringLiteral( "band21Width" ), mBand21Width, 4 );
  itemBand21Width = new KConfigCompilerSignallingItem(innerItemBand21Width, this, notifyFunction, signalBand21WidthChanged);
  innerItemBand21Width->setMinValue(0);
  innerItemBand21Width->setMaxValue(12);
  itemBand21Width->setWriteFlags(KConfigBase::Notify);
  itemBand21Width->setGroup(cgEqualizerinstanceIndexchannel);
  addItem( itemBand21Width, QStringLiteral( "band21Width" ) );
  KConfigCompilerSignallingItem  *itemBand22Width;
  KConfigBaseEE::ItemDouble  *innerItemBand22Width;
  innerItemBand22Width = new KConfigBaseEE::ItemDouble( currentGroup(), QStringLiteral( "band22Width" ), mBand22Width, 4 );
  itemBand22Width = new KConfigCompilerSignallingItem(innerItemBand22Width, this, notifyFunction, signalBand22WidthChanged);
  innerItemBand22Width->setMinValue(0);
  innerItemBand22Width->setMaxValue(12);
  itemBand22Width->setWriteFlags(KConfigBase::Notify);
  itemBand22Width->setGroup(cgEqualizerinstanceIndexchannel);
  addItem( itemBand22Width, QStringLiteral( "band22Width" ) );
  KConfigCompilerSignallingItem  *itemBand23Width;
  KConfigBaseEE::ItemDouble  *innerItemBand23Width;
  innerItemBand23Width = new KConfigBaseEE::ItemDouble( currentGroup(), QStringLiteral( "band23Width" ), mBand23Width, 4 );
  itemBand23Width = new KConfigCompilerSignallingItem(innerItemBand23Width, this, notifyFunction, signalBand23WidthChanged);
  innerItemBand23Width->setMinValue(0);
  innerItemBand23Width->setMaxValue(12);
  itemBand23Width->setWriteFlags(KConfigBase::Notify);
  itemBand23Width->setGroup(cgEqualizerinstanceIndexchannel);
  addItem( itemBand23Width, QStringLiteral( "band23Width" ) );
  KConfigCompilerSignallingItem  *itemBand24Width;
  KConfigBaseEE::ItemDouble  *innerItemBand24Width;
  innerItemBand24Width = new KConfigBaseEE::ItemDouble( currentGroup(), QStringLiteral( "band24Width" ), mBand24Width, 4 );
  itemBand24Width = new KConfigCompilerSignallingItem(innerItemBand24Width, this, notifyFunction, signalBand24WidthChanged);
  innerItemBand24Width->setMinValue(0);
  innerItemBand24Width->setMaxValue(12);
  itemBand24Width->setWriteFlags(KConfigBase::Notify);
  itemBand24Width->setGroup(cgEqualizerinstanceIndexchannel);
  addItem( itemBand24Width, QStringLiteral( "band24Width" ) );
  KConfigCompilerSignallingItem  *itemBand25Width;
  KConfigBaseEE::ItemDouble  *innerItemBand25Width;
  innerItemBand25Width = new KConfigBaseEE::ItemDouble( currentGroup(), QStringLiteral( "band25Width" ), mBand25Width, 4 );
  itemBand25Width = new KConfigCompilerSignallingItem(innerItemBand25Width, this, notifyFunction, signalBand25WidthChanged);
  innerItemBand25Width->setMinValue(0);
  innerItemBand25Width->setMaxValue(12);
  itemBand25Width->setWriteFlags(KConfigBase::Notify);
  itemBand25Width->setGroup(cgEqualizerinstanceIndexchannel);
  addItem( itemBand25Width, QStringLiteral( "band25Width" ) );
  KConfigCompilerSignallingItem  *itemBand26Width;
  KConfigBaseEE::ItemDouble  *innerItemBand26Width;
  innerItemBand26Width = new KConfigBaseEE::ItemDouble( currentGroup(), QStringLiteral( "band26Width" ), mBand26Width, 4 );
  itemBand26Width = new KConfigCompilerSignallingItem(innerItemBand26Width, this, notifyFunction, signalBand26WidthChanged);
  innerItemBand26Width->setMinValue(0);
  innerItemBand26Width->setMaxValue(12);
  itemBand26Width->setWriteFlags(KConfigBase::Notify);
  itemBand26Width->setGroup(cgEqualizerinstanceIndexchannel);
  addItem( itemBand26Width, QStringLiteral( "band26Width" ) );
  KConfigCompilerSignallingItem  *itemBand27Width;
  KConfigBaseEE::ItemDouble  *innerItemBand27Width;
  innerItemBand27Width = new KConfigBaseEE::ItemDouble( currentGroup(), QStringLiteral( "band27Width" ), mBand27Width, 4 );
  itemBand27Width = new KConfigCompilerSignallingItem(innerItemBand27Width, this, notifyFunction, signalBand27WidthChanged);
  innerItemBand27Width->setMinValue(0);
  innerItemBand27Width->setMaxValue(12);
  itemBand27Width->setWriteFlags(KConfigBase::Notify);
  itemBand27Width->setGroup(cgEqualizerinstanceIndexchannel);
  addItem( itemBand27Width, QStringLiteral( "band27Width" ) );
  KConfigCompilerSignallingItem  *itemBand28Width;
  KConfigBaseEE::ItemDouble  *innerItemBand28Width;
  innerItemBand28Width = new KConfigBaseEE::ItemDouble( currentGroup(), QStringLiteral( "band28Width" ), mBand28Width, 4 );
  itemBand28Width = new KConfigCompilerSignallingItem(innerItemBand28Width, this, notifyFunction, signalBand28WidthChanged);
  innerItemBand28Width->setMinValue(0);
  innerItemBand28Width->setMaxValue(12);
  itemBand28Width->setWriteFlags(KConfigBase::Notify);
  itemBand28Width->setGroup(cgEqualizerinstanceIndexchannel);
  addItem( itemBand28Width, QStringLiteral( "band28Width" ) );
  KConfigCompilerSignallingItem  *itemBand29Width;
  KConfigBaseEE::ItemDouble  *innerItemBand29Width;
  innerItemBand29Width = new KConfigBaseEE::ItemDouble( currentGroup(), QStringLiteral( "band29Width" ), mBand29Width, 4 );
  itemBand29Width = new KConfigCompilerSignallingItem(innerItemBand29Width, this, notifyFunction, signalBand29WidthChanged);
  innerItemBand29Width->setMinValue(0);
  innerItemBand29Width->setMaxValue(12);
  itemBand29Width->setWriteFlags(KConfigBase::Notify);
  itemBand29Width->setGroup(cgEqualizerinstanceIndexchannel);
  addItem( itemBand29Width, QStringLiteral( "band29Width" ) );
  KConfigCompilerSignallingItem  *itemBand30Width;
  KConfigBaseEE::ItemDouble  *innerItemBand30Width;
  innerItemBand30Width = new KConfigBaseEE::ItemDouble( currentGroup(), QStringLiteral( "band30Width" ), mBand30Width, 4 );
  itemBand30Width = new KConfigCompilerSignallingItem(innerItemBand30Width, this, notifyFunction, signalBand30WidthChanged);
  innerItemBand30Width->setMinValue(0);
  innerItemBand30Width->setMaxValue(12);
  itemBand30Width->setWriteFlags(KConfigBase::Notify);
  itemBand30Width->setGroup(cgEqualizerinstanceIndexchannel);
  addItem( itemBand30Width, QStringLiteral( "band30Width" ) );
  KConfigCompilerSignallingItem  *itemBand31Width;
  KConfigBaseEE::ItemDouble  *innerItemBand31Width;
  innerItemBand31Width = new KConfigBaseEE::ItemDouble( currentGroup(), QStringLiteral( "band31Width" ), mBand31Width, 4 );
  itemBand31Width = new KConfigCompilerSignallingItem(innerItemBand31Width, this, notifyFunction, signalBand31WidthChanged);
  innerItemBand31Width->setMinValue(0);
  innerItemBand31Width->setMaxValue(12);
  itemBand31Width->setWriteFlags(KConfigBase::Notify);
  itemBand31Width->setGroup(cgEqualizerinstanceIndexchannel);
  addItem( itemBand31Width, QStringLiteral( "band31Width" ) );
  KConfigCompilerSignallingItem  *itemBand0Type;
  KConfigBaseEE::ItemInt  *innerItemBand0Type;
  innerItemBand0Type = new KConfigBaseEE::ItemInt( currentGroup(), QStringLiteral( "band0Type" ), mBand0Type, 1 );
  itemBand0Type = new KConfigCompilerSignallingItem(innerItemBand0Type, this, notifyFunction, signalBand0TypeChanged);
  itemBand0Type->setWriteFlags(KConfigBase::Notify);
  itemBand0Type->setGroup(cgEqualizerinstanceIndexchannel);
  addItem( itemBand0Type, QStringLiteral( "band0Type" ) );
  KConfigCompilerSignallingItem  *itemBand1Type;
  KConfigBaseEE::ItemInt  *innerItemBand1Type;
  innerItemBand1Type = new KConfigBaseEE::ItemInt( currentGroup(), QStringLiteral( "band1Type" ), mBand1Type, 1 );
  itemBand1Type = new KConfigCompilerSignallingItem(innerItemBand1Type, this, notifyFunction, signalBand1TypeChanged);
  itemBand1Type->setWriteFlags(KConfigBase::Notify);
  itemBand1Type->setGroup(cgEqualizerinstanceIndexchannel);
  addItem( itemBand1Type, QStringLiteral( "band1Type" ) );
  KConfigCompilerSignallingItem  *itemBand2Type;
  KConfigBaseEE::ItemInt  *innerItemBand2Type;
  innerItemBand2Type = new KConfigBaseEE::ItemInt( currentGroup(), QStringLiteral( "band2Type" ), mBand2Type, 1 );
  itemBand2Type = new KConfigCompilerSignallingItem(innerItemBand2Type, this, notifyFunction, signalBand2TypeChanged);
  itemBand2Type->setWriteFlags(KConfigBase::Notify);
  itemBand2Type->setGroup(cgEqualizerinstanceIndexchannel);
  addItem( itemBand2Type, QStringLiteral( "band2Type" ) );
  KConfigCompilerSignallingItem  *itemBand3Type;
  KConfigBaseEE::ItemInt  *innerItemBand3Type;
  innerItemBand3Type = new KConfigBaseEE::ItemInt( currentGroup(), QStringLiteral( "band3Type" ), mBand3Type, 1 );
  itemBand3Type = new KConfigCompilerSignallingItem(innerItemBand3Type, this, notifyFunction, signalBand3TypeChanged);
  itemBand3Type->setWriteFlags(KConfigBase::Notify);
  itemBand3Type->setGroup(cgEqualizerinstanceIndexchannel);
  addItem( itemBand3Type, QStringLiteral( "band3Type" ) );
  KConfigCompilerSignallingItem  *itemBand4Type;
  KConfigBaseEE::ItemInt  *innerItemBand4Type;
  innerItemBand4Type = new KConfigBaseEE::ItemInt( currentGroup(), QStringLiteral( "band4Type" ), mBand4Type, 1 );
  itemBand4Type = new KConfigCompilerSignallingItem(innerItemBand4Type, this, notifyFunction, signalBand4TypeChanged);
  itemBand4Type->setWriteFlags(KConfigBase::Notify);
  itemBand4Type->setGroup(cgEqualizerinstanceIndexchannel);
  addItem( itemBand4Type, QStringLiteral( "band4Type" ) );
  KConfigCompilerSignallingItem  *itemBand5Type;
  KConfigBaseEE::ItemInt  *innerItemBand5Type;
  innerItemBand5Type = new KConfigBaseEE::ItemInt( currentGroup(), QStringLiteral( "band5Type" ), mBand5Type, 1 );
  itemBand5Type = new KConfigCompilerSignallingItem(innerItemBand5Type, this, notifyFunction, signalBand5TypeChanged);
  itemBand5Type->setWriteFlags(KConfigBase::Notify);
  itemBand5Type->setGroup(cgEqualizerinstanceIndexchannel);
  addItem( itemBand5Type, QStringLiteral( "band5Type" ) );
  KConfigCompilerSignallingItem  *itemBand6Type;
  KConfigBaseEE::ItemInt  *innerItemBand6Type;
  innerItemBand6Type = new KConfigBaseEE::ItemInt( currentGroup(), QStringLiteral( "band6Type" ), mBand6Type, 1 );
  itemBand6Type = new KConfigCompilerSignallingItem(innerItemBand6Type, this, notifyFunction, signalBand6TypeChanged);
  itemBand6Type->setWriteFlags(KConfigBase::Notify);
  itemBand6Type->setGroup(cgEqualizerinstanceIndexchannel);
  addItem( itemBand6Type, QStringLiteral( "band6Type" ) );
  KConfigCompilerSignallingItem  *itemBand7Type;
  KConfigBaseEE::ItemInt  *innerItemBand7Type;
  innerItemBand7Type = new KConfigBaseEE::ItemInt( currentGroup(), QStringLiteral( "band7Type" ), mBand7Type, 1 );
  itemBand7Type = new KConfigCompilerSignallingItem(innerItemBand7Type, this, notifyFunction, signalBand7TypeChanged);
  itemBand7Type->setWriteFlags(KConfigBase::Notify);
  itemBand7Type->setGroup(cgEqualizerinstanceIndexchannel);
  addItem( itemBand7Type, QStringLiteral( "band7Type" ) );
  KConfigCompilerSignallingItem  *itemBand8Type;
  KConfigBaseEE::ItemInt  *innerItemBand8Type;
  innerItemBand8Type = new KConfigBaseEE::ItemInt( currentGroup(), QStringLiteral( "band8Type" ), mBand8Type, 1 );
  itemBand8Type = new KConfigCompilerSignallingItem(innerItemBand8Type, this, notifyFunction, signalBand8TypeChanged);
  itemBand8Type->setWriteFlags(KConfigBase::Notify);
  itemBand8Type->setGroup(cgEqualizerinstanceIndexchannel);
  addItem( itemBand8Type, QStringLiteral( "band8Type" ) );
  KConfigCompilerSignallingItem  *itemBand9Type;
  KConfigBaseEE::ItemInt  *innerItemBand9Type;
  innerItemBand9Type = new KConfigBaseEE::ItemInt( currentGroup(), QStringLiteral( "band9Type" ), mBand9Type, 1 );
  itemBand9Type = new KConfigCompilerSignallingItem(innerItemBand9Type, this, notifyFunction, signalBand9TypeChanged);
  itemBand9Type->setWriteFlags(KConfigBase::Notify);
  itemBand9Type->setGroup(cgEqualizerinstanceIndexchannel);
  addItem( itemBand9Type, QStringLiteral( "band9Type" ) );
  KConfigCompilerSignallingItem  *itemBand10Type;
  KConfigBaseEE::ItemInt  *innerItemBand10Type;
  innerItemBand10Type = new KConfigBaseEE::ItemInt( currentGroup(), QStringLiteral( "band10Type" ), mBand10Type, 1 );
  itemBand10Type = new KConfigCompilerSignallingItem(innerItemBand10Type, this, notifyFunction, signalBand10TypeChanged);
  itemBand10Type->setWriteFlags(KConfigBase::Notify);
  itemBand10Type->setGroup(cgEqualizerinstanceIndexchannel);
  addItem( itemBand10Type, QStringLiteral( "band10Type" ) );
  KConfigCompilerSignallingItem  *itemBand11Type;
  KConfigBaseEE::ItemInt  *innerItemBand11Type;
  innerItemBand11Type = new KConfigBaseEE::ItemInt( currentGroup(), QStringLiteral( "band11Type" ), mBand11Type, 1 );
  itemBand11Type = new KConfigCompilerSignallingItem(innerItemBand11Type, this, notifyFunction, signalBand11TypeChanged);
  itemBand11Type->setWriteFlags(KConfigBase::Notify);
  itemBand11Type->setGroup(cgEqualizerinstanceIndexchannel);
  addItem( itemBand11Type, QStringLiteral( "band11Type" ) );
  KConfigCompilerSignallingItem  *itemBand12Type;
  KConfigBaseEE::ItemInt  *innerItemBand12Type;
  innerItemBand12Type = new KConfigBaseEE::ItemInt( currentGroup(), QStringLiteral( "band12Type" ), mBand12Type, 1 );
  itemBand12Type = new KConfigCompilerSignallingItem(innerItemBand12Type, this, notifyFunction, signalBand12TypeChanged);
  itemBand12Type->setWriteFlags(KConfigBase::Notify);
  itemBand12Type->setGroup(cgEqualizerinstanceIndexchannel);
  addItem( itemBand12Type, QStringLiteral( "band12Type" ) );
  KConfigCompilerSignallingItem  *itemBand13Type;
  KConfigBaseEE::ItemInt  *innerItemBand13Type;
  innerItemBand13Type = new KConfigBaseEE::ItemInt( currentGroup(), QStringLiteral( "band13Type" ), mBand13Type, 1 );
  itemBand13Type = new KConfigCompilerSignallingItem(innerItemBand13Type, this, notifyFunction, signalBand13TypeChanged);
  itemBand13Type->setWriteFlags(KConfigBase::Notify);
  itemBand13Type->setGroup(cgEqualizerinstanceIndexchannel);
  addItem( itemBand13Type, QStringLiteral( "band13Type" ) );
  KConfigCompilerSignallingItem  *itemBand14Type;
  KConfigBaseEE::ItemInt  *innerItemBand14Type;
  innerItemBand14Type = new KConfigBaseEE::ItemInt( currentGroup(), QStringLiteral( "band14Type" ), mBand14Type, 1 );
  itemBand14Type = new KConfigCompilerSignallingItem(innerItemBand14Type, this, notifyFunction, signalBand14TypeChanged);
  itemBand14Type->setWriteFlags(KConfigBase::Notify);
  itemBand14Type->setGroup(cgEqualizerinstanceIndexchannel);
  addItem( itemBand14Type, QStringLiteral( "band14Type" ) );
  KConfigCompilerSignallingItem  *itemBand15Type;
  KConfigBaseEE::ItemInt  *innerItemBand15Type;
  innerItemBand15Type = new KConfigBaseEE::ItemInt( currentGroup(), QStringLiteral( "band15Type" ), mBand15Type, 1 );
  itemBand15Type = new KConfigCompilerSignallingItem(innerItemBand15Type, this, notifyFunction, signalBand15TypeChanged);
  itemBand15Type->setWriteFlags(KConfigBase::Notify);
  itemBand15Type->setGroup(cgEqualizerinstanceIndexchannel);
  addItem( itemBand15Type, QStringLiteral( "band15Type" ) );
  KConfigCompilerSignallingItem  *itemBand16Type;
  KConfigBaseEE::ItemInt  *innerItemBand16Type;
  innerItemBand16Type = new KConfigBaseEE::ItemInt( currentGroup(), QStringLiteral( "band16Type" ), mBand16Type, 1 );
  itemBand16Type = new KConfigCompilerSignallingItem(innerItemBand16Type, this, notifyFunction, signalBand16TypeChanged);
  itemBand16Type->setWriteFlags(KConfigBase::Notify);
  itemBand16Type->setGroup(cgEqualizerinstanceIndexchannel);
  addItem( itemBand16Type, QStringLiteral( "band16Type" ) );
  KConfigCompilerSignallingItem  *itemBand17Type;
  KConfigBaseEE::ItemInt  *innerItemBand17Type;
  innerItemBand17Type = new KConfigBaseEE::ItemInt( currentGroup(), QStringLiteral( "band17Type" ), mBand17Type, 1 );
  itemBand17Type = new KConfigCompilerSignallingItem(innerItemBand17Type, this, notifyFunction, signalBand17TypeChanged);
  itemBand17Type->setWriteFlags(KConfigBase::Notify);
  itemBand17Type->setGroup(cgEqualizerinstanceIndexchannel);
  addItem( itemBand17Type, QStringLiteral( "band17Type" ) );
  KConfigCompilerSignallingItem  *itemBand18Type;
  KConfigBaseEE::ItemInt  *innerItemBand18Type;
  innerItemBand18Type = new KConfigBaseEE::ItemInt( currentGroup(), QStringLiteral( "band18Type" ), mBand18Type, 1 );
  itemBand18Type = new KConfigCompilerSignallingItem(innerItemBand18Type, this, notifyFunction, signalBand18TypeChanged);
  itemBand18Type->setWriteFlags(KConfigBase::Notify);
  itemBand18Type->setGroup(cgEqualizerinstanceIndexchannel);
  addItem( itemBand18Type, QStringLiteral( "band18Type" ) );
  KConfigCompilerSignallingItem  *itemBand19Type;
  KConfigBaseEE::ItemInt  *innerItemBand19Type;
  innerItemBand19Type = new KConfigBaseEE::ItemInt( currentGroup(), QStringLiteral( "band19Type" ), mBand19Type, 1 );
  itemBand19Type = new KConfigCompilerSignallingItem(innerItemBand19Type, this, notifyFunction, signalBand19TypeChanged);
  itemBand19Type->setWriteFlags(KConfigBase::Notify);
  itemBand19Type->setGroup(cgEqualizerinstanceIndexchannel);
  addItem( itemBand19Type, QStringLiteral( "band19Type" ) );
  KConfigCompilerSignallingItem  *itemBand20Type;
  KConfigBaseEE::ItemInt  *innerItemBand20Type;
  innerItemBand20Type = new KConfigBaseEE::ItemInt( currentGroup(), QStringLiteral( "band20Type" ), mBand20Type, 1 );
  itemBand20Type = new KConfigCompilerSignallingItem(innerItemBand20Type, this, notifyFunction, signalBand20TypeChanged);
  itemBand20Type->setWriteFlags(KConfigBase::Notify);
  itemBand20Type->setGroup(cgEqualizerinstanceIndexchannel);
  addItem( itemBand20Type, QStringLiteral( "band20Type" ) );
  KConfigCompilerSignallingItem  *itemBand21Type;
  KConfigBaseEE::ItemInt  *innerItemBand21Type;
  innerItemBand21Type = new KConfigBaseEE::ItemInt( currentGroup(), QStringLiteral( "band21Type" ), mBand21Type, 1 );
  itemBand21Type = new KConfigCompilerSignallingItem(innerItemBand21Type, this, notifyFunction, signalBand21TypeChanged);
  itemBand21Type->setWriteFlags(KConfigBase::Notify);
  itemBand21Type->setGroup(cgEqualizerinstanceIndexchannel);
  addItem( itemBand21Type, QStringLiteral( "band21Type" ) );
  KConfigCompilerSignallingItem  *itemBand22Type;
  KConfigBaseEE::ItemInt  *innerItemBand22Type;
  innerItemBand22Type = new KConfigBaseEE::ItemInt( currentGroup(), QStringLiteral( "band22Type" ), mBand22Type, 1 );
  itemBand22Type = new KConfigCompilerSignallingItem(innerItemBand22Type, this, notifyFunction, signalBand22TypeChanged);
  itemBand22Type->setWriteFlags(KConfigBase::Notify);
  itemBand22Type->setGroup(cgEqualizerinstanceIndexchannel);
  addItem( itemBand22Type, QStringLiteral( "band22Type" ) );
  KConfigCompilerSignallingItem  *itemBand23Type;
  KConfigBaseEE::ItemInt  *innerItemBand23Type;
  innerItemBand23Type = new KConfigBaseEE::ItemInt( currentGroup(), QStringLiteral( "band23Type" ), mBand23Type, 1 );
  itemBand23Type = new KConfigCompilerSignallingItem(innerItemBand23Type, this, notifyFunction, signalBand23TypeChanged);
  itemBand23Type->setWriteFlags(KConfigBase::Notify);
  itemBand23Type->setGroup(cgEqualizerinstanceIndexchannel);
  addItem( itemBand23Type, QStringLiteral( "band23Type" ) );
  KConfigCompilerSignallingItem  *itemBand24Type;
  KConfigBaseEE::ItemInt  *innerItemBand24Type;
  innerItemBand24Type = new KConfigBaseEE::ItemInt( currentGroup(), QStringLiteral( "band24Type" ), mBand24Type, 1 );
  itemBand24Type = new KConfigCompilerSignallingItem(innerItemBand24Type, this, notifyFunction, signalBand24TypeChanged);
  itemBand24Type->setWriteFlags(KConfigBase::Notify);
  itemBand24Type->setGroup(cgEqualizerinstanceIndexchannel);
  addItem( itemBand24Type, QStringLiteral( "band24Type" ) );
  KConfigCompilerSignallingItem  *itemBand25Type;
  KConfigBaseEE::ItemInt  *innerItemBand25Type;
  innerItemBand25Type = new KConfigBaseEE::ItemInt( currentGroup(), QStringLiteral( "band25Type" ), mBand25Type, 1 );
  itemBand25Type = new KConfigCompilerSignallingItem(innerItemBand25Type, this, notifyFunction, signalBand25TypeChanged);
  itemBand25Type->setWriteFlags(KConfigBase::Notify);
  itemBand25Type->setGroup(cgEqualizerinstanceIndexchannel);
  addItem( itemBand25Type, QStringLiteral( "band25Type" ) );
  KConfigCompilerSignallingItem  *itemBand26Type;
  KConfigBaseEE::ItemInt  *innerItemBand26Type;
  innerItemBand26Type = new KConfigBaseEE::ItemInt( currentGroup(), QStringLiteral( "band26Type" ), mBand26Type, 1 );
  itemBand26Type = new KConfigCompilerSignallingItem(innerItemBand26Type, this, notifyFunction, signalBand26TypeChanged);
  itemBand26Type->setWriteFlags(KConfigBase::Notify);
  itemBand26Type->setGroup(cgEqualizerinstanceIndexchannel);
  addItem( itemBand26Type, QStringLiteral( "band26Type" ) );
  KConfigCompilerSignallingItem  *itemBand27Type;
  KConfigBaseEE::ItemInt  *innerItemBand27Type;
  innerItemBand27Type = new KConfigBaseEE::ItemInt( currentGroup(), QStringLiteral( "band27Type" ), mBand27Type, 1 );
  itemBand27Type = new KConfigCompilerSignallingItem(innerItemBand27Type, this, notifyFunction, signalBand27TypeChanged);
  itemBand27Type->setWriteFlags(KConfigBase::Notify);
  itemBand27Type->setGroup(cgEqualizerinstanceIndexchannel);
  addItem( itemBand27Type, QStringLiteral( "band27Type" ) );
  KConfigCompilerSignallingItem  *itemBand28Type;
  KConfigBaseEE::ItemInt  *innerItemBand28Type;
  innerItemBand28Type = new KConfigBaseEE::ItemInt( currentGroup(), QStringLiteral( "band28Type" ), mBand28Type, 1 );
  itemBand28Type = new KConfigCompilerSignallingItem(innerItemBand28Type, this, notifyFunction, signalBand28TypeChanged);
  itemBand28Type->setWriteFlags(KConfigBase::Notify);
  itemBand28Type->setGroup(cgEqualizerinstanceIndexchannel);
  addItem( itemBand28Type, QStringLiteral( "band28Type" ) );
  KConfigCompilerSignallingItem  *itemBand29Type;
  KConfigBaseEE::ItemInt  *innerItemBand29Type;
  innerItemBand29Type = new KConfigBaseEE::ItemInt( currentGroup(), QStringLiteral( "band29Type" ), mBand29Type, 1 );
  itemBand29Type = new KConfigCompilerSignallingItem(innerItemBand29Type, this, notifyFunction, signalBand29TypeChanged);
  itemBand29Type->setWriteFlags(KConfigBase::Notify);
  itemBand29Type->setGroup(cgEqualizerinstanceIndexchannel);
  addItem( itemBand29Type, QStringLiteral( "band29Type" ) );
  KConfigCompilerSignallingItem  *itemBand30Type;
  KConfigBaseEE::ItemInt  *innerItemBand30Type;
  innerItemBand30Type = new KConfigBaseEE::ItemInt( currentGroup(), QStringLiteral( "band30Type" ), mBand30Type, 1 );
  itemBand30Type = new KConfigCompilerSignallingItem(innerItemBand30Type, this, notifyFunction, signalBand30TypeChanged);
  itemBand30Type->setWriteFlags(KConfigBase::Notify);
  itemBand30Type->setGroup(cgEqualizerinstanceIndexchannel);
  addItem( itemBand30Type, QStringLiteral( "band30Type" ) );
  KConfigCompilerSignallingItem  *itemBand31Type;
  KConfigBaseEE::ItemInt  *innerItemBand31Type;
  innerItemBand31Type = new KConfigBaseEE::ItemInt( currentGroup(), QStringLiteral( "band31Type" ), mBand31Type, 1 );
  itemBand31Type = new KConfigCompilerSignallingItem(innerItemBand31Type, this, notifyFunction, signalBand31TypeChanged);
  itemBand31Type->setWriteFlags(KConfigBase::Notify);
  itemBand31Type->setGroup(cgEqualizerinstanceIndexchannel);
  addItem( itemBand31Type, QStringLiteral( "band31Type" ) );
  KConfigCompilerSignallingItem  *itemBand0Mode;
  KConfigBaseEE::ItemInt  *innerItemBand0Mode;
  innerItemBand0Mode = new KConfigBaseEE::ItemInt( currentGroup(), QStringLiteral( "band0Mode" ), mBand0Mode, 0 );
  itemBand0Mode = new KConfigCompilerSignallingItem(innerItemBand0Mode, this, notifyFunction, signalBand0ModeChanged);
  itemBand0Mode->setWriteFlags(KConfigBase::Notify);
  itemBand0Mode->setGroup(cgEqualizerinstanceIndexchannel);
  addItem( itemBand0Mode, QStringLiteral( "band0Mode" ) );
  KConfigCompilerSignallingItem  *itemBand1Mode;
  KConfigBaseEE::ItemInt  *innerItemBand1Mode;
  innerItemBand1Mode = new KConfigBaseEE::ItemInt( currentGroup(), QStringLiteral( "band1Mode" ), mBand1Mode, 0 );
  itemBand1Mode = new KConfigCompilerSignallingItem(innerItemBand1Mode, this, notifyFunction, signalBand1ModeChanged);
  itemBand1Mode->setWriteFlags(KConfigBase::Notify);
  itemBand1Mode->setGroup(cgEqualizerinstanceIndexchannel);
  addItem( itemBand1Mode, QStringLiteral( "band1Mode" ) );
  KConfigCompilerSignallingItem  *itemBand2Mode;
  KConfigBaseEE::ItemInt  *innerItemBand2Mode;
  innerItemBand2Mode = new KConfigBaseEE::ItemInt( currentGroup(), QStringLiteral( "band2Mode" ), mBand2Mode, 0 );
  itemBand2Mode = new KConfigCompilerSignallingItem(innerItemBand2Mode, this, notifyFunction, signalBand2ModeChanged);
  itemBand2Mode->setWriteFlags(KConfigBase::Notify);
  itemBand2Mode->setGroup(cgEqualizerinstanceIndexchannel);
  addItem( itemBand2Mode, QStringLiteral( "band2Mode" ) );
  KConfigCompilerSignallingItem  *itemBand3Mode;
  KConfigBaseEE::ItemInt  *innerItemBand3Mode;
  innerItemBand3Mode = new KConfigBaseEE::ItemInt( currentGroup(), QStringLiteral( "band3Mode" ), mBand3Mode, 0 );
  itemBand3Mode = new KConfigCompilerSignallingItem(innerItemBand3Mode, this, notifyFunction, signalBand3ModeChanged);
  itemBand3Mode->setWriteFlags(KConfigBase::Notify);
  itemBand3Mode->setGroup(cgEqualizerinstanceIndexchannel);
  addItem( itemBand3Mode, QStringLiteral( "band3Mode" ) );
  KConfigCompilerSignallingItem  *itemBand4Mode;
  KConfigBaseEE::ItemInt  *innerItemBand4Mode;
  innerItemBand4Mode = new KConfigBaseEE::ItemInt( currentGroup(), QStringLiteral( "band4Mode" ), mBand4Mode, 0 );
  itemBand4Mode = new KConfigCompilerSignallingItem(innerItemBand4Mode, this, notifyFunction, signalBand4ModeChanged);
  itemBand4Mode->setWriteFlags(KConfigBase::Notify);
  itemBand4Mode->setGroup(cgEqualizerinstanceIndexchannel);
  addItem( itemBand4Mode, QStringLiteral( "band4Mode" ) );
  KConfigCompilerSignallingItem  *itemBand5Mode;
  KConfigBaseEE::ItemInt  *innerItemBand5Mode;
  innerItemBand5Mode = new KConfigBaseEE::ItemInt( currentGroup(), QStringLiteral( "band5Mode" ), mBand5Mode, 0 );
  itemBand5Mode = new KConfigCompilerSignallingItem(innerItemBand5Mode, this, notifyFunction, signalBand5ModeChanged);
  itemBand5Mode->setWriteFlags(KConfigBase::Notify);
  itemBand5Mode->setGroup(cgEqualizerinstanceIndexchannel);
  addItem( itemBand5Mode, QStringLiteral( "band5Mode" ) );
  KConfigCompilerSignallingItem  *itemBand6Mode;
  KConfigBaseEE::ItemInt  *innerItemBand6Mode;
  innerItemBand6Mode = new KConfigBaseEE::ItemInt( currentGroup(), QStringLiteral( "band6Mode" ), mBand6Mode, 0 );
  itemBand6Mode = new KConfigCompilerSignallingItem(innerItemBand6Mode, this, notifyFunction, signalBand6ModeChanged);
  itemBand6Mode->setWriteFlags(KConfigBase::Notify);
  itemBand6Mode->setGroup(cgEqualizerinstanceIndexchannel);
  addItem( itemBand6Mode, QStringLiteral( "band6Mode" ) );
  KConfigCompilerSignallingItem  *itemBand7Mode;
  KConfigBaseEE::ItemInt  *innerItemBand7Mode;
  innerItemBand7Mode = new KConfigBaseEE::ItemInt( currentGroup(), QStringLiteral( "band7Mode" ), mBand7Mode, 0 );
  itemBand7Mode = new KConfigCompilerSignallingItem(innerItemBand7Mode, this, notifyFunction, signalBand7ModeChanged);
  itemBand7Mode->setWriteFlags(KConfigBase::Notify);
  itemBand7Mode->setGroup(cgEqualizerinstanceIndexchannel);
  addItem( itemBand7Mode, QStringLiteral( "band7Mode" ) );
  KConfigCompilerSignallingItem  *itemBand8Mode;
  KConfigBaseEE::ItemInt  *innerItemBand8Mode;
  innerItemBand8Mode = new KConfigBaseEE::ItemInt( currentGroup(), QStringLiteral( "band8Mode" ), mBand8Mode, 0 );
  itemBand8Mode = new KConfigCompilerSignallingItem(innerItemBand8Mode, this, notifyFunction, signalBand8ModeChanged);
  itemBand8Mode->setWriteFlags(KConfigBase::Notify);
  itemBand8Mode->setGroup(cgEqualizerinstanceIndexchannel);
  addItem( itemBand8Mode, QStringLiteral( "band8Mode" ) );
  KConfigCompilerSignallingItem  *itemBand9Mode;
  KConfigBaseEE::ItemInt  *innerItemBand9Mode;
  innerItemBand9Mode = new KConfigBaseEE::ItemInt( currentGroup(), QStringLiteral( "band9Mode" ), mBand9Mode, 0 );
  itemBand9Mode = new KConfigCompilerSignallingItem(innerItemBand9Mode, this, notifyFunction, signalBand9ModeChanged);
  itemBand9Mode->setWriteFlags(KConfigBase::Notify);
  itemBand9Mode->setGroup(cgEqualizerinstanceIndexchannel);
  addItem( itemBand9Mode, QStringLiteral( "band9Mode" ) );
  KConfigCompilerSignallingItem  *itemBand10Mode;
  KConfigBaseEE::ItemInt  *innerItemBand10Mode;
  innerItemBand10Mode = new KConfigBaseEE::ItemInt( currentGroup(), QStringLiteral( "band10Mode" ), mBand10Mode, 0 );
  itemBand10Mode = new KConfigCompilerSignallingItem(innerItemBand10Mode, this, notifyFunction, signalBand10ModeChanged);
  itemBand10Mode->setWriteFlags(KConfigBase::Notify);
  itemBand10Mode->setGroup(cgEqualizerinstanceIndexchannel);
  addItem( itemBand10Mode, QStringLiteral( "band10Mode" ) );
  KConfigCompilerSignallingItem  *itemBand11Mode;
  KConfigBaseEE::ItemInt  *innerItemBand11Mode;
  innerItemBand11Mode = new KConfigBaseEE::ItemInt( currentGroup(), QStringLiteral( "band11Mode" ), mBand11Mode, 0 );
  itemBand11Mode = new KConfigCompilerSignallingItem(innerItemBand11Mode, this, notifyFunction, signalBand11ModeChanged);
  itemBand11Mode->setWriteFlags(KConfigBase::Notify);
  itemBand11Mode->setGroup(cgEqualizerinstanceIndexchannel);
  addItem( itemBand11Mode, QStringLiteral( "band11Mode" ) );
  KConfigCompilerSignallingItem  *itemBand12Mode;
  KConfigBaseEE::ItemInt  *innerItemBand12Mode;
  innerItemBand12Mode = new KConfigBaseEE::ItemInt( currentGroup(), QStringLiteral( "band12Mode" ), mBand12Mode, 0 );
  itemBand12Mode = new KConfigCompilerSignallingItem(innerItemBand12Mode, this, notifyFunction, signalBand12ModeChanged);
  itemBand12Mode->setWriteFlags(KConfigBase::Notify);
  itemBand12Mode->setGroup(cgEqualizerinstanceIndexchannel);
  addItem( itemBand12Mode, QStringLiteral( "band12Mode" ) );
  KConfigCompilerSignallingItem  *itemBand13Mode;
  KConfigBaseEE::ItemInt  *innerItemBand13Mode;
  innerItemBand13Mode = new KConfigBaseEE::ItemInt( currentGroup(), QStringLiteral( "band13Mode" ), mBand13Mode, 0 );
  itemBand13Mode = new KConfigCompilerSignallingItem(innerItemBand13Mode, this, notifyFunction, signalBand13ModeChanged);
  itemBand13Mode->setWriteFlags(KConfigBase::Notify);
  itemBand13Mode->setGroup(cgEqualizerinstanceIndexchannel);
  addItem( itemBand13Mode, QStringLiteral( "band13Mode" ) );
  KConfigCompilerSignallingItem  *itemBand14Mode;
  KConfigBaseEE::ItemInt  *innerItemBand14Mode;
  innerItemBand14Mode = new KConfigBaseEE::ItemInt( currentGroup(), QStringLiteral( "band14Mode" ), mBand14Mode, 0 );
  itemBand14Mode = new KConfigCompilerSignallingItem(innerItemBand14Mode, this, notifyFunction, signalBand14ModeChanged);
  itemBand14Mode->setWriteFlags(KConfigBase::Notify);
  itemBand14Mode->setGroup(cgEqualizerinstanceIndexchannel);
  addItem( itemBand14Mode, QStringLiteral( "band14Mode" ) );
  KConfigCompilerSignallingItem  *itemBand15Mode;
  KConfigBaseEE::ItemInt  *innerItemBand15Mode;
  innerItemBand15Mode = new KConfigBaseEE::ItemInt( currentGroup(), QStringLiteral( "band15Mode" ), mBand15Mode, 0 );
  itemBand15Mode = new KConfigCompilerSignallingItem(innerItemBand15Mode, this, notifyFunction, signalBand15ModeChanged);
  itemBand15Mode->setWriteFlags(KConfigBase::Notify);
  itemBand15Mode->setGroup(cgEqualizerinstanceIndexchannel);
  addItem( itemBand15Mode, QStringLiteral( "band15Mode" ) );
  KConfigCompilerSignallingItem  *itemBand16Mode;
  KConfigBaseEE::ItemInt  *innerItemBand16Mode;
  innerItemBand16Mode = new KConfigBaseEE::ItemInt( currentGroup(), QStringLiteral( "band16Mode" ), mBand16Mode, 0 );
  itemBand16Mode = new KConfigCompilerSignallingItem(innerItemBand16Mode, this, notifyFunction, signalBand16ModeChanged);
  itemBand16Mode->setWriteFlags(KConfigBase::Notify);
  itemBand16Mode->setGroup(cgEqualizerinstanceIndexchannel);
  addItem( itemBand16Mode, QStringLiteral( "band16Mode" ) );
  KConfigCompilerSignallingItem  *itemBand17Mode;
  KConfigBaseEE::ItemInt  *innerItemBand17Mode;
  innerItemBand17Mode = new KConfigBaseEE::ItemInt( currentGroup(), QStringLiteral( "band17Mode" ), mBand17Mode, 0 );
  itemBand17Mode = new KConfigCompilerSignallingItem(innerItemBand17Mode, this, notifyFunction, signalBand17ModeChanged);
  itemBand17Mode->setWriteFlags(KConfigBase::Notify);
  itemBand17Mode->setGroup(cgEqualizerinstanceIndexchannel);
  addItem( itemBand17Mode, QStringLiteral( "band17Mode" ) );
  KConfigCompilerSignallingItem  *itemBand18Mode;
  KConfigBaseEE::ItemInt  *innerItemBand18Mode;
  innerItemBand18Mode = new KConfigBaseEE::ItemInt( currentGroup(), QStringLiteral( "band18Mode" ), mBand18Mode, 0 );
  itemBand18Mode = new KConfigCompilerSignallingItem(innerItemBand18Mode, this, notifyFunction, signalBand18ModeChanged);
  itemBand18Mode->setWriteFlags(KConfigBase::Notify);
  itemBand18Mode->setGroup(cgEqualizerinstanceIndexchannel);
  addItem( itemBand18Mode, QStringLiteral( "band18Mode" ) );
  KConfigCompilerSignallingItem  *itemBand19Mode;
  KConfigBaseEE::ItemInt  *innerItemBand19Mode;
  innerItemBand19Mode = new KConfigBaseEE::ItemInt( currentGroup(), QStringLiteral( "band19Mode" ), mBand19Mode, 0 );
  itemBand19Mode = new KConfigCompilerSignallingItem(innerItemBand19Mode, this, notifyFunction, signalBand19ModeChanged);
  itemBand19Mode->setWriteFlags(KConfigBase::Notify);
  itemBand19Mode->setGroup(cgEqualizerinstanceIndexchannel);
  addItem( itemBand19Mode, QStringLiteral( "band19Mode" ) );
  KConfigCompilerSignallingItem  *itemBand20Mode;
  KConfigBaseEE::ItemInt  *innerItemBand20Mode;
  innerItemBand20Mode = new KConfigBaseEE::ItemInt( currentGroup(), QStringLiteral( "band20Mode" ), mBand20Mode, 0 );
  itemBand20Mode = new KConfigCompilerSignallingItem(innerItemBand20Mode, this, notifyFunction, signalBand20ModeChanged);
  itemBand20Mode->setWriteFlags(KConfigBase::Notify);
  itemBand20Mode->setGroup(cgEqualizerinstanceIndexchannel);
  addItem( itemBand20Mode, QStringLiteral( "band20Mode" ) );
  KConfigCompilerSignallingItem  *itemBand21Mode;
  KConfigBaseEE::ItemInt  *innerItemBand21Mode;
  innerItemBand21Mode = new KConfigBaseEE::ItemInt( currentGroup(), QStringLiteral( "band21Mode" ), mBand21Mode, 0 );
  itemBand21Mode = new KConfigCompilerSignallingItem(innerItemBand21Mode, this, notifyFunction, signalBand21ModeChanged);
  itemBand21Mode->setWriteFlags(KConfigBase::Notify);
  itemBand21Mode->setGroup(cgEqualizerinstanceIndexchannel);
  addItem( itemBand21Mode, QStringLiteral( "band21Mode" ) );
  KConfigCompilerSignallingItem  *itemBand22Mode;
  KConfigBaseEE::ItemInt  *innerItemBand22Mode;
  innerItemBand22Mode = new KConfigBaseEE::ItemInt( currentGroup(), QStringLiteral( "band22Mode" ), mBand22Mode, 0 );
  itemBand22Mode = new KConfigCompilerSignallingItem(innerItemBand22Mode, this, notifyFunction, signalBand22ModeChanged);
  itemBand22Mode->setWriteFlags(KConfigBase::Notify);
  itemBand22Mode->setGroup(cgEqualizerinstanceIndexchannel);
  addItem( itemBand22Mode, QStringLiteral( "band22Mode" ) );
  KConfigCompilerSignallingItem  *itemBand23Mode;
  KConfigBaseEE::ItemInt  *innerItemBand23Mode;
  innerItemBand23Mode = new KConfigBaseEE::ItemInt( currentGroup(), QStringLiteral( "band23Mode" ), mBand23Mode, 0 );
  itemBand23Mode = new KConfigCompilerSignallingItem(innerItemBand23Mode, this, notifyFunction, signalBand23ModeChanged);
  itemBand23Mode->setWriteFlags(KConfigBase::Notify);
  itemBand23Mode->setGroup(cgEqualizerinstanceIndexchannel);
  addItem( itemBand23Mode, QStringLiteral( "band23Mode" ) );
  KConfigCompilerSignallingItem  *itemBand24Mode;
  KConfigBaseEE::ItemInt  *innerItemBand24Mode;
  innerItemBand24Mode = new KConfigBaseEE::ItemInt( currentGroup(), QStringLiteral( "band24Mode" ), mBand24Mode, 0 );
  itemBand24Mode = new KConfigCompilerSignallingItem(innerItemBand24Mode, this, notifyFunction, signalBand24ModeChanged);
  itemBand24Mode->setWriteFlags(KConfigBase::Notify);
  itemBand24Mode->setGroup(cgEqualizerinstanceIndexchannel);
  addItem( itemBand24Mode, QStringLiteral( "band24Mode" ) );
  KConfigCompilerSignallingItem  *itemBand25Mode;
  KConfigBaseEE::ItemInt  *innerItemBand25Mode;
  innerItemBand25Mode = new KConfigBaseEE::ItemInt( currentGroup(), QStringLiteral( "band25Mode" ), mBand25Mode, 0 );
  itemBand25Mode = new KConfigCompilerSignallingItem(innerItemBand25Mode, this, notifyFunction, signalBand25ModeChanged);
  itemBand25Mode->setWriteFlags(KConfigBase::Notify);
  itemBand25Mode->setGroup(cgEqualizerinstanceIndexchannel);
  addItem( itemBand25Mode, QStringLiteral( "band25Mode" ) );
  KConfigCompilerSignallingItem  *itemBand26Mode;
  KConfigBaseEE::ItemInt  *innerItemBand26Mode;
  innerItemBand26Mode = new KConfigBaseEE::ItemInt( currentGroup(), QStringLiteral( "band26Mode" ), mBand26Mode, 0 );
  itemBand26Mode = new KConfigCompilerSignallingItem(innerItemBand26Mode, this, notifyFunction, signalBand26ModeChanged);
  itemBand26Mode->setWriteFlags(KConfigBase::Notify);
  itemBand26Mode->setGroup(cgEqualizerinstanceIndexchannel);
  addItem( itemBand26Mode, QStringLiteral( "band26Mode" ) );
  KConfigCompilerSignallingItem  *itemBand27Mode;
  KConfigBaseEE::ItemInt  *innerItemBand27Mode;
  innerItemBand27Mode = new KConfigBaseEE::ItemInt( currentGroup(), QStringLiteral( "band27Mode" ), mBand27Mode, 0 );
  itemBand27Mode = new KConfigCompilerSignallingItem(innerItemBand27Mode, this, notifyFunction, signalBand27ModeChanged);
  itemBand27Mode->setWriteFlags(KConfigBase::Notify);
  itemBand27Mode->setGroup(cgEqualizerinstanceIndexchannel);
  addItem( itemBand27Mode, QStringLiteral( "band27Mode" ) );
  KConfigCompilerSignallingItem  *itemBand28Mode;
  KConfigBaseEE::ItemInt  *innerItemBand28Mode;
  innerItemBand28Mode = new KConfigBaseEE::ItemInt( currentGroup(), QStringLiteral( "band28Mode" ), mBand28Mode, 0 );
  itemBand28Mode = new KConfigCompilerSignallingItem(innerItemBand28Mode, this, notifyFunction, signalBand28ModeChanged);
  itemBand28Mode->setWriteFlags(KConfigBase::Notify);
  itemBand28Mode->setGroup(cgEqualizerinstanceIndexchannel);
  addItem( itemBand28Mode, QStringLiteral( "band28Mode" ) );
  KConfigCompilerSignallingItem  *itemBand29Mode;
  KConfigBaseEE::ItemInt  *innerItemBand29Mode;
  innerItemBand29Mode = new KConfigBaseEE::ItemInt( currentGroup(), QStringLiteral( "band29Mode" ), mBand29Mode, 0 );
  itemBand29Mode = new KConfigCompilerSignallingItem(innerItemBand29Mode, this, notifyFunction, signalBand29ModeChanged);
  itemBand29Mode->setWriteFlags(KConfigBase::Notify);
  itemBand29Mode->setGroup(cgEqualizerinstanceIndexchannel);
  addItem( itemBand29Mode, QStringLiteral( "band29Mode" ) );
  KConfigCompilerSignallingItem  *itemBand30Mode;
  KConfigBaseEE::ItemInt  *innerItemBand30Mode;
  innerItemBand30Mode = new KConfigBaseEE::ItemInt( currentGroup(), QStringLiteral( "band30Mode" ), mBand30Mode, 0 );
  itemBand30Mode = new KConfigCompilerSignallingItem(innerItemBand30Mode, this, notifyFunction, signalBand30ModeChanged);
  itemBand30Mode->setWriteFlags(KConfigBase::Notify);
  itemBand30Mode->setGroup(cgEqualizerinstanceIndexchannel);
  addItem( itemBand30Mode, QStringLiteral( "band30Mode" ) );
  KConfigCompilerSignallingItem  *itemBand31Mode;
  KConfigBaseEE::ItemInt  *innerItemBand31Mode;
  innerItemBand31Mode = new KConfigBaseEE::ItemInt( currentGroup(), QStringLiteral( "band31Mode" ), mBand31Mode, 0 );
  itemBand31Mode = new KConfigCompilerSignallingItem(innerItemBand31Mode, this, notifyFunction, signalBand31ModeChanged);
  itemBand31Mode->setWriteFlags(KConfigBase::Notify);
  itemBand31Mode->setGroup(cgEqualizerinstanceIndexchannel);
  addItem( itemBand31Mode, QStringLiteral( "band31Mode" ) );
  KConfigCompilerSignallingItem  *itemBand0Slope;
  KConfigBaseEE::ItemInt  *innerItemBand0Slope;
  innerItemBand0Slope = new KConfigBaseEE::ItemInt( currentGroup(), QStringLiteral( "band0Slope" ), mBand0Slope, 0 );
  itemBand0Slope = new KConfigCompilerSignallingItem(innerItemBand0Slope, this, notifyFunction, signalBand0SlopeChanged);
  itemBand0Slope->setWriteFlags(KConfigBase::Notify);
  itemBand0Slope->setGroup(cgEqualizerinstanceIndexchannel);
  addItem( itemBand0Slope, QStringLiteral( "band0Slope" ) );
  KConfigCompilerSignallingItem  *itemBand1Slope;
  KConfigBaseEE::ItemInt  *innerItemBand1Slope;
  innerItemBand1Slope = new KConfigBaseEE::ItemInt( currentGroup(), QStringLiteral( "band1Slope" ), mBand1Slope, 0 );
  itemBand1Slope = new KConfigCompilerSignallingItem(innerItemBand1Slope, this, notifyFunction, signalBand1SlopeChanged);
  itemBand1Slope->setWriteFlags(KConfigBase::Notify);
  itemBand1Slope->setGroup(cgEqualizerinstanceIndexchannel);
  addItem( itemBand1Slope, QStringLiteral( "band1Slope" ) );
  KConfigCompilerSignallingItem  *itemBand2Slope;
  KConfigBaseEE::ItemInt  *innerItemBand2Slope;
  innerItemBand2Slope = new KConfigBaseEE::ItemInt( currentGroup(), QStringLiteral( "band2Slope" ), mBand2Slope, 0 );
  itemBand2Slope = new KConfigCompilerSignallingItem(innerItemBand2Slope, this, notifyFunction, signalBand2SlopeChanged);
  itemBand2Slope->setWriteFlags(KConfigBase::Notify);
  itemBand2Slope->setGroup(cgEqualizerinstanceIndexchannel);
  addItem( itemBand2Slope, QStringLiteral( "band2Slope" ) );
  KConfigCompilerSignallingItem  *itemBand3Slope;
  KConfigBaseEE::ItemInt  *innerItemBand3Slope;
  innerItemBand3Slope = new KConfigBaseEE::ItemInt( currentGroup(), QStringLiteral( "band3Slope" ), mBand3Slope, 0 );
  itemBand3Slope = new KConfigCompilerSignallingItem(innerItemBand3Slope, this, notifyFunction, signalBand3SlopeChanged);
  itemBand3Slope->setWriteFlags(KConfigBase::Notify);
  itemBand3Slope->setGroup(cgEqualizerinstanceIndexchannel);
  addItem( itemBand3Slope, QStringLiteral( "band3Slope" ) );
  KConfigCompilerSignallingItem  *itemBand4Slope;
  KConfigBaseEE::ItemInt  *innerItemBand4Slope;
  innerItemBand4Slope = new KConfigBaseEE::ItemInt( currentGroup(), QStringLiteral( "band4Slope" ), mBand4Slope, 0 );
  itemBand4Slope = new KConfigCompilerSignallingItem(innerItemBand4Slope, this, notifyFunction, signalBand4SlopeChanged);
  itemBand4Slope->setWriteFlags(KConfigBase::Notify);
  itemBand4Slope->setGroup(cgEqualizerinstanceIndexchannel);
  addItem( itemBand4Slope, QStringLiteral( "band4Slope" ) );
  KConfigCompilerSignallingItem  *itemBand5Slope;
  KConfigBaseEE::ItemInt  *innerItemBand5Slope;
  innerItemBand5Slope = new KConfigBaseEE::ItemInt( currentGroup(), QStringLiteral( "band5Slope" ), mBand5Slope, 0 );
  itemBand5Slope = new KConfigCompilerSignallingItem(innerItemBand5Slope, this, notifyFunction, signalBand5SlopeChanged);
  itemBand5Slope->setWriteFlags(KConfigBase::Notify);
  itemBand5Slope->setGroup(cgEqualizerinstanceIndexchannel);
  addItem( itemBand5Slope, QStringLiteral( "band5Slope" ) );
  KConfigCompilerSignallingItem  *itemBand6Slope;
  KConfigBaseEE::ItemInt  *innerItemBand6Slope;
  innerItemBand6Slope = new KConfigBaseEE::ItemInt( currentGroup(), QStringLiteral( "band6Slope" ), mBand6Slope, 0 );
  itemBand6Slope = new KConfigCompilerSignallingItem(innerItemBand6Slope, this, notifyFunction, signalBand6SlopeChanged);
  itemBand6Slope->setWriteFlags(KConfigBase::Notify);
  itemBand6Slope->setGroup(cgEqualizerinstanceIndexchannel);
  addItem( itemBand6Slope, QStringLiteral( "band6Slope" ) );
  KConfigCompilerSignallingItem  *itemBand7Slope;
  KConfigBaseEE::ItemInt  *innerItemBand7Slope;
  innerItemBand7Slope = new KConfigBaseEE::ItemInt( currentGroup(), QStringLiteral( "band7Slope" ), mBand7Slope, 0 );
  itemBand7Slope = new KConfigCompilerSignallingItem(innerItemBand7Slope, this, notifyFunction, signalBand7SlopeChanged);
  itemBand7Slope->setWriteFlags(KConfigBase::Notify);
  itemBand7Slope->setGroup(cgEqualizerinstanceIndexchannel);
  addItem( itemBand7Slope, QStringLiteral( "band7Slope" ) );
  KConfigCompilerSignallingItem  *itemBand8Slope;
  KConfigBaseEE::ItemInt  *innerItemBand8Slope;
  innerItemBand8Slope = new KConfigBaseEE::ItemInt( currentGroup(), QStringLiteral( "band8Slope" ), mBand8Slope, 0 );
  itemBand8Slope = new KConfigCompilerSignallingItem(innerItemBand8Slope, this, notifyFunction, signalBand8SlopeChanged);
  itemBand8Slope->setWriteFlags(KConfigBase::Notify);
  itemBand8Slope->setGroup(cgEqualizerinstanceIndexchannel);
  addItem( itemBand8Slope, QStringLiteral( "band8Slope" ) );
  KConfigCompilerSignallingItem  *itemBand9Slope;
  KConfigBaseEE::ItemInt  *innerItemBand9Slope;
  innerItemBand9Slope = new KConfigBaseEE::ItemInt( currentGroup(), QStringLiteral( "band9Slope" ), mBand9Slope, 0 );
  itemBand9Slope = new KConfigCompilerSignallingItem(innerItemBand9Slope, this, notifyFunction, signalBand9SlopeChanged);
  itemBand9Slope->setWriteFlags(KConfigBase::Notify);
  itemBand9Slope->setGroup(cgEqualizerinstanceIndexchannel);
  addItem( itemBand9Slope, QStringLiteral( "band9Slope" ) );
  KConfigCompilerSignallingItem  *itemBand10Slope;
  KConfigBaseEE::ItemInt  *innerItemBand10Slope;
  innerItemBand10Slope = new KConfigBaseEE::ItemInt( currentGroup(), QStringLiteral( "band10Slope" ), mBand10Slope, 0 );
  itemBand10Slope = new KConfigCompilerSignallingItem(innerItemBand10Slope, this, notifyFunction, signalBand10SlopeChanged);
  itemBand10Slope->setWriteFlags(KConfigBase::Notify);
  itemBand10Slope->setGroup(cgEqualizerinstanceIndexchannel);
  addItem( itemBand10Slope, QStringLiteral( "band10Slope" ) );
  KConfigCompilerSignallingItem  *itemBand11Slope;
  KConfigBaseEE::ItemInt  *innerItemBand11Slope;
  innerItemBand11Slope = new KConfigBaseEE::ItemInt( currentGroup(), QStringLiteral( "band11Slope" ), mBand11Slope, 0 );
  itemBand11Slope = new KConfigCompilerSignallingItem(innerItemBand11Slope, this, notifyFunction, signalBand11SlopeChanged);
  itemBand11Slope->setWriteFlags(KConfigBase::Notify);
  itemBand11Slope->setGroup(cgEqualizerinstanceIndexchannel);
  addItem( itemBand11Slope, QStringLiteral( "band11Slope" ) );
  KConfigCompilerSignallingItem  *itemBand12Slope;
  KConfigBaseEE::ItemInt  *innerItemBand12Slope;
  innerItemBand12Slope = new KConfigBaseEE::ItemInt( currentGroup(), QStringLiteral( "band12Slope" ), mBand12Slope, 0 );
  itemBand12Slope = new KConfigCompilerSignallingItem(innerItemBand12Slope, this, notifyFunction, signalBand12SlopeChanged);
  itemBand12Slope->setWriteFlags(KConfigBase::Notify);
  itemBand12Slope->setGroup(cgEqualizerinstanceIndexchannel);
  addItem( itemBand12Slope, QStringLiteral( "band12Slope" ) );
  KConfigCompilerSignallingItem  *itemBand13Slope;
  KConfigBaseEE::ItemInt  *innerItemBand13Slope;
  innerItemBand13Slope = new KConfigBaseEE::ItemInt( currentGroup(), QStringLiteral( "band13Slope" ), mBand13Slope, 0 );
  itemBand13Slope = new KConfigCompilerSignallingItem(innerItemBand13Slope, this, notifyFunction, signalBand13SlopeChanged);
  itemBand13Slope->setWriteFlags(KConfigBase::Notify);
  itemBand13Slope->setGroup(cgEqualizerinstanceIndexchannel);
  addItem( itemBand13Slope, QStringLiteral( "band13Slope" ) );
  KConfigCompilerSignallingItem  *itemBand14Slope;
  KConfigBaseEE::ItemInt  *innerItemBand14Slope;
  innerItemBand14Slope = new KConfigBaseEE::ItemInt( currentGroup(), QStringLiteral( "band14Slope" ), mBand14Slope, 0 );
  itemBand14Slope = new KConfigCompilerSignallingItem(innerItemBand14Slope, this, notifyFunction, signalBand14SlopeChanged);
  itemBand14Slope->setWriteFlags(KConfigBase::Notify);
  itemBand14Slope->setGroup(cgEqualizerinstanceIndexchannel);
  addItem( itemBand14Slope, QStringLiteral( "band14Slope" ) );
  KConfigCompilerSignallingItem  *itemBand15Slope;
  KConfigBaseEE::ItemInt  *innerItemBand15Slope;
  innerItemBand15Slope = new KConfigBaseEE::ItemInt( currentGroup(), QStringLiteral( "band15Slope" ), mBand15Slope, 0 );
  itemBand15Slope = new KConfigCompilerSignallingItem(innerItemBand15Slope, this, notifyFunction, signalBand15SlopeChanged);
  itemBand15Slope->setWriteFlags(KConfigBase::Notify);
  itemBand15Slope->setGroup(cgEqualizerinstanceIndexchannel);
  addItem( itemBand15Slope, QStringLiteral( "band15Slope" ) );
  KConfigCompilerSignallingItem  *itemBand16Slope;
  KConfigBaseEE::ItemInt  *innerItemBand16Slope;
  innerItemBand16Slope = new KConfigBaseEE::ItemInt( currentGroup(), QStringLiteral( "band16Slope" ), mBand16Slope, 0 );
  itemBand16Slope = new KConfigCompilerSignallingItem(innerItemBand16Slope, this, notifyFunction, signalBand16SlopeChanged);
  itemBand16Slope->setWriteFlags(KConfigBase::Notify);
  itemBand16Slope->setGroup(cgEqualizerinstanceIndexchannel);
  addItem( itemBand16Slope, QStringLiteral( "band16Slope" ) );
  KConfigCompilerSignallingItem  *itemBand17Slope;
  KConfigBaseEE::ItemInt  *innerItemBand17Slope;
  innerItemBand17Slope = new KConfigBaseEE::ItemInt( currentGroup(), QStringLiteral( "band17Slope" ), mBand17Slope, 0 );
  itemBand17Slope = new KConfigCompilerSignallingItem(innerItemBand17Slope, this, notifyFunction, signalBand17SlopeChanged);
  itemBand17Slope->setWriteFlags(KConfigBase::Notify);
  itemBand17Slope->setGroup(cgEqualizerinstanceIndexchannel);
  addItem( itemBand17Slope, QStringLiteral( "band17Slope" ) );
  KConfigCompilerSignallingItem  *itemBand18Slope;
  KConfigBaseEE::ItemInt  *innerItemBand18Slope;
  innerItemBand18Slope = new KConfigBaseEE::ItemInt( currentGroup(), QStringLiteral( "band18Slope" ), mBand18Slope, 0 );
  itemBand18Slope = new KConfigCompilerSignallingItem(innerItemBand18Slope, this, notifyFunction, signalBand18SlopeChanged);
  itemBand18Slope->setWriteFlags(KConfigBase::Notify);
  itemBand18Slope->setGroup(cgEqualizerinstanceIndexchannel);
  addItem( itemBand18Slope, QStringLiteral( "band18Slope" ) );
  KConfigCompilerSignallingItem  *itemBand19Slope;
  KConfigBaseEE::ItemInt  *innerItemBand19Slope;
  innerItemBand19Slope = new KConfigBaseEE::ItemInt( currentGroup(), QStringLiteral( "band19Slope" ), mBand19Slope, 0 );
  itemBand19Slope = new KConfigCompilerSignallingItem(innerItemBand19Slope, this, notifyFunction, signalBand19SlopeChanged);
  itemBand19Slope->setWriteFlags(KConfigBase::Notify);
  itemBand19Slope->setGroup(cgEqualizerinstanceIndexchannel);
  addItem( itemBand19Slope, QStringLiteral( "band19Slope" ) );
  KConfigCompilerSignallingItem  *itemBand20Slope;
  KConfigBaseEE::ItemInt  *innerItemBand20Slope;
  innerItemBand20Slope = new KConfigBaseEE::ItemInt( currentGroup(), QStringLiteral( "band20Slope" ), mBand20Slope, 0 );
  itemBand20Slope = new KConfigCompilerSignallingItem(innerItemBand20Slope, this, notifyFunction, signalBand20SlopeChanged);
  itemBand20Slope->setWriteFlags(KConfigBase::Notify);
  itemBand20Slope->setGroup(cgEqualizerinstanceIndexchannel);
  addItem( itemBand20Slope, QStringLiteral( "band20Slope" ) );
  KConfigCompilerSignallingItem  *itemBand21Slope;
  KConfigBaseEE::ItemInt  *innerItemBand21Slope;
  innerItemBand21Slope = new KConfigBaseEE::ItemInt( currentGroup(), QStringLiteral( "band21Slope" ), mBand21Slope, 0 );
  itemBand21Slope = new KConfigCompilerSignallingItem(innerItemBand21Slope, this, notifyFunction, signalBand21SlopeChanged);
  itemBand21Slope->setWriteFlags(KConfigBase::Notify);
  itemBand21Slope->setGroup(cgEqualizerinstanceIndexchannel);
  addItem( itemBand21Slope, QStringLiteral( "band21Slope" ) );
  KConfigCompilerSignallingItem  *itemBand22Slope;
  KConfigBaseEE::ItemInt  *innerItemBand22Slope;
  innerItemBand22Slope = new KConfigBaseEE::ItemInt( currentGroup(), QStringLiteral( "band22Slope" ), mBand22Slope, 0 );
  itemBand22Slope = new KConfigCompilerSignallingItem(innerItemBand22Slope, this, notifyFunction, signalBand22SlopeChanged);
  itemBand22Slope->setWriteFlags(KConfigBase::Notify);
  itemBand22Slope->setGroup(cgEqualizerinstanceIndexchannel);
  addItem( itemBand22Slope, QStringLiteral( "band22Slope" ) );
  KConfigCompilerSignallingItem  *itemBand23Slope;
  KConfigBaseEE::ItemInt  *innerItemBand23Slope;
  innerItemBand23Slope = new KConfigBaseEE::ItemInt( currentGroup(), QStringLiteral( "band23Slope" ), mBand23Slope, 0 );
  itemBand23Slope = new KConfigCompilerSignallingItem(innerItemBand23Slope, this, notifyFunction, signalBand23SlopeChanged);
  itemBand23Slope->setWriteFlags(KConfigBase::Notify);
  itemBand23Slope->setGroup(cgEqualizerinstanceIndexchannel);
  addItem( itemBand23Slope, QStringLiteral( "band23Slope" ) );
  KConfigCompilerSignallingItem  *itemBand24Slope;
  KConfigBaseEE::ItemInt  *innerItemBand24Slope;
  innerItemBand24Slope = new KConfigBaseEE::ItemInt( currentGroup(), QStringLiteral( "band24Slope" ), mBand24Slope, 0 );
  itemBand24Slope = new KConfigCompilerSignallingItem(innerItemBand24Slope, this, notifyFunction, signalBand24SlopeChanged);
  itemBand24Slope->setWriteFlags(KConfigBase::Notify);
  itemBand24Slope->setGroup(cgEqualizerinstanceIndexchannel);
  addItem( itemBand24Slope, QStringLiteral( "band24Slope" ) );
  KConfigCompilerSignallingItem  *itemBand25Slope;
  KConfigBaseEE::ItemInt  *innerItemBand25Slope;
  innerItemBand25Slope = new KConfigBaseEE::ItemInt( currentGroup(), QStringLiteral( "band25Slope" ), mBand25Slope, 0 );
  itemBand25Slope = new KConfigCompilerSignallingItem(innerItemBand25Slope, this, notifyFunction, signalBand25SlopeChanged);
  itemBand25Slope->setWriteFlags(KConfigBase::Notify);
  itemBand25Slope->setGroup(cgEqualizerinstanceIndexchannel);
  addItem( itemBand25Slope, QStringLiteral( "band25Slope" ) );
  KConfigCompilerSignallingItem  *itemBand26Slope;
  KConfigBaseEE::ItemInt  *innerItemBand26Slope;
  innerItemBand26Slope = new KConfigBaseEE::ItemInt( currentGroup(), QStringLiteral( "band26Slope" ), mBand26Slope, 0 );
  itemBand26Slope = new KConfigCompilerSignallingItem(innerItemBand26Slope, this, notifyFunction, signalBand26SlopeChanged);
  itemBand26Slope->setWriteFlags(KConfigBase::Notify);
  itemBand26Slope->setGroup(cgEqualizerinstanceIndexchannel);
  addItem( itemBand26Slope, QStringLiteral( "band26Slope" ) );
  KConfigCompilerSignallingItem  *itemBand27Slope;
  KConfigBaseEE::ItemInt  *innerItemBand27Slope;
  innerItemBand27Slope = new KConfigBaseEE::ItemInt( currentGroup(), QStringLiteral( "band27Slope" ), mBand27Slope, 0 );
  itemBand27Slope = new KConfigCompilerSignallingItem(innerItemBand27Slope, this, notifyFunction, signalBand27SlopeChanged);
  itemBand27Slope->setWriteFlags(KConfigBase::Notify);
  itemBand27Slope->setGroup(cgEqualizerinstanceIndexchannel);
  addItem( itemBand27Slope, QStringLiteral( "band27Slope" ) );
  KConfigCompilerSignallingItem  *itemBand28Slope;
  KConfigBaseEE::ItemInt  *innerItemBand28Slope;
  innerItemBand28Slope = new KConfigBaseEE::ItemInt( currentGroup(), QStringLiteral( "band28Slope" ), mBand28Slope, 0 );
  itemBand28Slope = new KConfigCompilerSignallingItem(innerItemBand28Slope, this, notifyFunction, signalBand28SlopeChanged);
  itemBand28Slope->setWriteFlags(KConfigBase::Notify);
  itemBand28Slope->setGroup(cgEqualizerinstanceIndexchannel);
  addItem( itemBand28Slope, QStringLiteral( "band28Slope" ) );
  KConfigCompilerSignallingItem  *itemBand29Slope;
  KConfigBaseEE::ItemInt  *innerItemBand29Slope;
  innerItemBand29Slope = new KConfigBaseEE::ItemInt( currentGroup(), QStringLiteral( "band29Slope" ), mBand29Slope, 0 );
  itemBand29Slope = new KConfigCompilerSignallingItem(innerItemBand29Slope, this, notifyFunction, signalBand29SlopeChanged);
  itemBand29Slope->setWriteFlags(KConfigBase::Notify);
  itemBand29Slope->setGroup(cgEqualizerinstanceIndexchannel);
  addItem( itemBand29Slope, QStringLiteral( "band29Slope" ) );
  KConfigCompilerSignallingItem  *itemBand30Slope;
  KConfigBaseEE::ItemInt  *innerItemBand30Slope;
  innerItemBand30Slope = new KConfigBaseEE::ItemInt( currentGroup(), QStringLiteral( "band30Slope" ), mBand30Slope, 0 );
  itemBand30Slope = new KConfigCompilerSignallingItem(innerItemBand30Slope, this, notifyFunction, signalBand30SlopeChanged);
  itemBand30Slope->setWriteFlags(KConfigBase::Notify);
  itemBand30Slope->setGroup(cgEqualizerinstanceIndexchannel);
  addItem( itemBand30Slope, QStringLiteral( "band30Slope" ) );
  KConfigCompilerSignallingItem  *itemBand31Slope;
  KConfigBaseEE::ItemInt  *innerItemBand31Slope;
  innerItemBand31Slope = new KConfigBaseEE::ItemInt( currentGroup(), QStringLiteral( "band31Slope" ), mBand31Slope, 0 );
  itemBand31Slope = new KConfigCompilerSignallingItem(innerItemBand31Slope, this, notifyFunction, signalBand31SlopeChanged);
  itemBand31Slope->setWriteFlags(KConfigBase::Notify);
  itemBand31Slope->setGroup(cgEqualizerinstanceIndexchannel);
  addItem( itemBand31Slope, QStringLiteral( "band31Slope" ) );
  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(cgEqualizerinstanceIndexchannel);
  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(cgEqualizerinstanceIndexchannel);
  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(cgEqualizerinstanceIndexchannel);
  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(cgEqualizerinstanceIndexchannel);
  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(cgEqualizerinstanceIndexchannel);
  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(cgEqualizerinstanceIndexchannel);
  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(cgEqualizerinstanceIndexchannel);
  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(cgEqualizerinstanceIndexchannel);
  addItem( itemBand7Solo, QStringLiteral( "band7Solo" ) );
  KConfigCompilerSignallingItem  *itemBand8Solo;
  KConfigBaseEE::ItemBool  *innerItemBand8Solo;
  innerItemBand8Solo = new KConfigBaseEE::ItemBool( currentGroup(), QStringLiteral( "band8Solo" ), mBand8Solo, false );
  itemBand8Solo = new KConfigCompilerSignallingItem(innerItemBand8Solo, this, notifyFunction, signalBand8SoloChanged);
  itemBand8Solo->setWriteFlags(KConfigBase::Notify);
  itemBand8Solo->setGroup(cgEqualizerinstanceIndexchannel);
  addItem( itemBand8Solo, QStringLiteral( "band8Solo" ) );
  KConfigCompilerSignallingItem  *itemBand9Solo;
  KConfigBaseEE::ItemBool  *innerItemBand9Solo;
  innerItemBand9Solo = new KConfigBaseEE::ItemBool( currentGroup(), QStringLiteral( "band9Solo" ), mBand9Solo, false );
  itemBand9Solo = new KConfigCompilerSignallingItem(innerItemBand9Solo, this, notifyFunction, signalBand9SoloChanged);
  itemBand9Solo->setWriteFlags(KConfigBase::Notify);
  itemBand9Solo->setGroup(cgEqualizerinstanceIndexchannel);
  addItem( itemBand9Solo, QStringLiteral( "band9Solo" ) );
  KConfigCompilerSignallingItem  *itemBand10Solo;
  KConfigBaseEE::ItemBool  *innerItemBand10Solo;
  innerItemBand10Solo = new KConfigBaseEE::ItemBool( currentGroup(), QStringLiteral( "band10Solo" ), mBand10Solo, false );
  itemBand10Solo = new KConfigCompilerSignallingItem(innerItemBand10Solo, this, notifyFunction, signalBand10SoloChanged);
  itemBand10Solo->setWriteFlags(KConfigBase::Notify);
  itemBand10Solo->setGroup(cgEqualizerinstanceIndexchannel);
  addItem( itemBand10Solo, QStringLiteral( "band10Solo" ) );
  KConfigCompilerSignallingItem  *itemBand11Solo;
  KConfigBaseEE::ItemBool  *innerItemBand11Solo;
  innerItemBand11Solo = new KConfigBaseEE::ItemBool( currentGroup(), QStringLiteral( "band11Solo" ), mBand11Solo, false );
  itemBand11Solo = new KConfigCompilerSignallingItem(innerItemBand11Solo, this, notifyFunction, signalBand11SoloChanged);
  itemBand11Solo->setWriteFlags(KConfigBase::Notify);
  itemBand11Solo->setGroup(cgEqualizerinstanceIndexchannel);
  addItem( itemBand11Solo, QStringLiteral( "band11Solo" ) );
  KConfigCompilerSignallingItem  *itemBand12Solo;
  KConfigBaseEE::ItemBool  *innerItemBand12Solo;
  innerItemBand12Solo = new KConfigBaseEE::ItemBool( currentGroup(), QStringLiteral( "band12Solo" ), mBand12Solo, false );
  itemBand12Solo = new KConfigCompilerSignallingItem(innerItemBand12Solo, this, notifyFunction, signalBand12SoloChanged);
  itemBand12Solo->setWriteFlags(KConfigBase::Notify);
  itemBand12Solo->setGroup(cgEqualizerinstanceIndexchannel);
  addItem( itemBand12Solo, QStringLiteral( "band12Solo" ) );
  KConfigCompilerSignallingItem  *itemBand13Solo;
  KConfigBaseEE::ItemBool  *innerItemBand13Solo;
  innerItemBand13Solo = new KConfigBaseEE::ItemBool( currentGroup(), QStringLiteral( "band13Solo" ), mBand13Solo, false );
  itemBand13Solo = new KConfigCompilerSignallingItem(innerItemBand13Solo, this, notifyFunction, signalBand13SoloChanged);
  itemBand13Solo->setWriteFlags(KConfigBase::Notify);
  itemBand13Solo->setGroup(cgEqualizerinstanceIndexchannel);
  addItem( itemBand13Solo, QStringLiteral( "band13Solo" ) );
  KConfigCompilerSignallingItem  *itemBand14Solo;
  KConfigBaseEE::ItemBool  *innerItemBand14Solo;
  innerItemBand14Solo = new KConfigBaseEE::ItemBool( currentGroup(), QStringLiteral( "band14Solo" ), mBand14Solo, false );
  itemBand14Solo = new KConfigCompilerSignallingItem(innerItemBand14Solo, this, notifyFunction, signalBand14SoloChanged);
  itemBand14Solo->setWriteFlags(KConfigBase::Notify);
  itemBand14Solo->setGroup(cgEqualizerinstanceIndexchannel);
  addItem( itemBand14Solo, QStringLiteral( "band14Solo" ) );
  KConfigCompilerSignallingItem  *itemBand15Solo;
  KConfigBaseEE::ItemBool  *innerItemBand15Solo;
  innerItemBand15Solo = new KConfigBaseEE::ItemBool( currentGroup(), QStringLiteral( "band15Solo" ), mBand15Solo, false );
  itemBand15Solo = new KConfigCompilerSignallingItem(innerItemBand15Solo, this, notifyFunction, signalBand15SoloChanged);
  itemBand15Solo->setWriteFlags(KConfigBase::Notify);
  itemBand15Solo->setGroup(cgEqualizerinstanceIndexchannel);
  addItem( itemBand15Solo, QStringLiteral( "band15Solo" ) );
  KConfigCompilerSignallingItem  *itemBand16Solo;
  KConfigBaseEE::ItemBool  *innerItemBand16Solo;
  innerItemBand16Solo = new KConfigBaseEE::ItemBool( currentGroup(), QStringLiteral( "band16Solo" ), mBand16Solo, false );
  itemBand16Solo = new KConfigCompilerSignallingItem(innerItemBand16Solo, this, notifyFunction, signalBand16SoloChanged);
  itemBand16Solo->setWriteFlags(KConfigBase::Notify);
  itemBand16Solo->setGroup(cgEqualizerinstanceIndexchannel);
  addItem( itemBand16Solo, QStringLiteral( "band16Solo" ) );
  KConfigCompilerSignallingItem  *itemBand17Solo;
  KConfigBaseEE::ItemBool  *innerItemBand17Solo;
  innerItemBand17Solo = new KConfigBaseEE::ItemBool( currentGroup(), QStringLiteral( "band17Solo" ), mBand17Solo, false );
  itemBand17Solo = new KConfigCompilerSignallingItem(innerItemBand17Solo, this, notifyFunction, signalBand17SoloChanged);
  itemBand17Solo->setWriteFlags(KConfigBase::Notify);
  itemBand17Solo->setGroup(cgEqualizerinstanceIndexchannel);
  addItem( itemBand17Solo, QStringLiteral( "band17Solo" ) );
  KConfigCompilerSignallingItem  *itemBand18Solo;
  KConfigBaseEE::ItemBool  *innerItemBand18Solo;
  innerItemBand18Solo = new KConfigBaseEE::ItemBool( currentGroup(), QStringLiteral( "band18Solo" ), mBand18Solo, false );
  itemBand18Solo = new KConfigCompilerSignallingItem(innerItemBand18Solo, this, notifyFunction, signalBand18SoloChanged);
  itemBand18Solo->setWriteFlags(KConfigBase::Notify);
  itemBand18Solo->setGroup(cgEqualizerinstanceIndexchannel);
  addItem( itemBand18Solo, QStringLiteral( "band18Solo" ) );
  KConfigCompilerSignallingItem  *itemBand19Solo;
  KConfigBaseEE::ItemBool  *innerItemBand19Solo;
  innerItemBand19Solo = new KConfigBaseEE::ItemBool( currentGroup(), QStringLiteral( "band19Solo" ), mBand19Solo, false );
  itemBand19Solo = new KConfigCompilerSignallingItem(innerItemBand19Solo, this, notifyFunction, signalBand19SoloChanged);
  itemBand19Solo->setWriteFlags(KConfigBase::Notify);
  itemBand19Solo->setGroup(cgEqualizerinstanceIndexchannel);
  addItem( itemBand19Solo, QStringLiteral( "band19Solo" ) );
  KConfigCompilerSignallingItem  *itemBand20Solo;
  KConfigBaseEE::ItemBool  *innerItemBand20Solo;
  innerItemBand20Solo = new KConfigBaseEE::ItemBool( currentGroup(), QStringLiteral( "band20Solo" ), mBand20Solo, false );
  itemBand20Solo = new KConfigCompilerSignallingItem(innerItemBand20Solo, this, notifyFunction, signalBand20SoloChanged);
  itemBand20Solo->setWriteFlags(KConfigBase::Notify);
  itemBand20Solo->setGroup(cgEqualizerinstanceIndexchannel);
  addItem( itemBand20Solo, QStringLiteral( "band20Solo" ) );
  KConfigCompilerSignallingItem  *itemBand21Solo;
  KConfigBaseEE::ItemBool  *innerItemBand21Solo;
  innerItemBand21Solo = new KConfigBaseEE::ItemBool( currentGroup(), QStringLiteral( "band21Solo" ), mBand21Solo, false );
  itemBand21Solo = new KConfigCompilerSignallingItem(innerItemBand21Solo, this, notifyFunction, signalBand21SoloChanged);
  itemBand21Solo->setWriteFlags(KConfigBase::Notify);
  itemBand21Solo->setGroup(cgEqualizerinstanceIndexchannel);
  addItem( itemBand21Solo, QStringLiteral( "band21Solo" ) );
  KConfigCompilerSignallingItem  *itemBand22Solo;
  KConfigBaseEE::ItemBool  *innerItemBand22Solo;
  innerItemBand22Solo = new KConfigBaseEE::ItemBool( currentGroup(), QStringLiteral( "band22Solo" ), mBand22Solo, false );
  itemBand22Solo = new KConfigCompilerSignallingItem(innerItemBand22Solo, this, notifyFunction, signalBand22SoloChanged);
  itemBand22Solo->setWriteFlags(KConfigBase::Notify);
  itemBand22Solo->setGroup(cgEqualizerinstanceIndexchannel);
  addItem( itemBand22Solo, QStringLiteral( "band22Solo" ) );
  KConfigCompilerSignallingItem  *itemBand23Solo;
  KConfigBaseEE::ItemBool  *innerItemBand23Solo;
  innerItemBand23Solo = new KConfigBaseEE::ItemBool( currentGroup(), QStringLiteral( "band23Solo" ), mBand23Solo, false );
  itemBand23Solo = new KConfigCompilerSignallingItem(innerItemBand23Solo, this, notifyFunction, signalBand23SoloChanged);
  itemBand23Solo->setWriteFlags(KConfigBase::Notify);
  itemBand23Solo->setGroup(cgEqualizerinstanceIndexchannel);
  addItem( itemBand23Solo, QStringLiteral( "band23Solo" ) );
  KConfigCompilerSignallingItem  *itemBand24Solo;
  KConfigBaseEE::ItemBool  *innerItemBand24Solo;
  innerItemBand24Solo = new KConfigBaseEE::ItemBool( currentGroup(), QStringLiteral( "band24Solo" ), mBand24Solo, false );
  itemBand24Solo = new KConfigCompilerSignallingItem(innerItemBand24Solo, this, notifyFunction, signalBand24SoloChanged);
  itemBand24Solo->setWriteFlags(KConfigBase::Notify);
  itemBand24Solo->setGroup(cgEqualizerinstanceIndexchannel);
  addItem( itemBand24Solo, QStringLiteral( "band24Solo" ) );
  KConfigCompilerSignallingItem  *itemBand25Solo;
  KConfigBaseEE::ItemBool  *innerItemBand25Solo;
  innerItemBand25Solo = new KConfigBaseEE::ItemBool( currentGroup(), QStringLiteral( "band25Solo" ), mBand25Solo, false );
  itemBand25Solo = new KConfigCompilerSignallingItem(innerItemBand25Solo, this, notifyFunction, signalBand25SoloChanged);
  itemBand25Solo->setWriteFlags(KConfigBase::Notify);
  itemBand25Solo->setGroup(cgEqualizerinstanceIndexchannel);
  addItem( itemBand25Solo, QStringLiteral( "band25Solo" ) );
  KConfigCompilerSignallingItem  *itemBand26Solo;
  KConfigBaseEE::ItemBool  *innerItemBand26Solo;
  innerItemBand26Solo = new KConfigBaseEE::ItemBool( currentGroup(), QStringLiteral( "band26Solo" ), mBand26Solo, false );
  itemBand26Solo = new KConfigCompilerSignallingItem(innerItemBand26Solo, this, notifyFunction, signalBand26SoloChanged);
  itemBand26Solo->setWriteFlags(KConfigBase::Notify);
  itemBand26Solo->setGroup(cgEqualizerinstanceIndexchannel);
  addItem( itemBand26Solo, QStringLiteral( "band26Solo" ) );
  KConfigCompilerSignallingItem  *itemBand27Solo;
  KConfigBaseEE::ItemBool  *innerItemBand27Solo;
  innerItemBand27Solo = new KConfigBaseEE::ItemBool( currentGroup(), QStringLiteral( "band27Solo" ), mBand27Solo, false );
  itemBand27Solo = new KConfigCompilerSignallingItem(innerItemBand27Solo, this, notifyFunction, signalBand27SoloChanged);
  itemBand27Solo->setWriteFlags(KConfigBase::Notify);
  itemBand27Solo->setGroup(cgEqualizerinstanceIndexchannel);
  addItem( itemBand27Solo, QStringLiteral( "band27Solo" ) );
  KConfigCompilerSignallingItem  *itemBand28Solo;
  KConfigBaseEE::ItemBool  *innerItemBand28Solo;
  innerItemBand28Solo = new KConfigBaseEE::ItemBool( currentGroup(), QStringLiteral( "band28Solo" ), mBand28Solo, false );
  itemBand28Solo = new KConfigCompilerSignallingItem(innerItemBand28Solo, this, notifyFunction, signalBand28SoloChanged);
  itemBand28Solo->setWriteFlags(KConfigBase::Notify);
  itemBand28Solo->setGroup(cgEqualizerinstanceIndexchannel);
  addItem( itemBand28Solo, QStringLiteral( "band28Solo" ) );
  KConfigCompilerSignallingItem  *itemBand29Solo;
  KConfigBaseEE::ItemBool  *innerItemBand29Solo;
  innerItemBand29Solo = new KConfigBaseEE::ItemBool( currentGroup(), QStringLiteral( "band29Solo" ), mBand29Solo, false );
  itemBand29Solo = new KConfigCompilerSignallingItem(innerItemBand29Solo, this, notifyFunction, signalBand29SoloChanged);
  itemBand29Solo->setWriteFlags(KConfigBase::Notify);
  itemBand29Solo->setGroup(cgEqualizerinstanceIndexchannel);
  addItem( itemBand29Solo, QStringLiteral( "band29Solo" ) );
  KConfigCompilerSignallingItem  *itemBand30Solo;
  KConfigBaseEE::ItemBool  *innerItemBand30Solo;
  innerItemBand30Solo = new KConfigBaseEE::ItemBool( currentGroup(), QStringLiteral( "band30Solo" ), mBand30Solo, false );
  itemBand30Solo = new KConfigCompilerSignallingItem(innerItemBand30Solo, this, notifyFunction, signalBand30SoloChanged);
  itemBand30Solo->setWriteFlags(KConfigBase::Notify);
  itemBand30Solo->setGroup(cgEqualizerinstanceIndexchannel);
  addItem( itemBand30Solo, QStringLiteral( "band30Solo" ) );
  KConfigCompilerSignallingItem  *itemBand31Solo;
  KConfigBaseEE::ItemBool  *innerItemBand31Solo;
  innerItemBand31Solo = new KConfigBaseEE::ItemBool( currentGroup(), QStringLiteral( "band31Solo" ), mBand31Solo, false );
  itemBand31Solo = new KConfigCompilerSignallingItem(innerItemBand31Solo, this, notifyFunction, signalBand31SoloChanged);
  itemBand31Solo->setWriteFlags(KConfigBase::Notify);
  itemBand31Solo->setGroup(cgEqualizerinstanceIndexchannel);
  addItem( itemBand31Solo, QStringLiteral( "band31Solo" ) );
  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(cgEqualizerinstanceIndexchannel);
  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(cgEqualizerinstanceIndexchannel);
  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(cgEqualizerinstanceIndexchannel);
  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(cgEqualizerinstanceIndexchannel);
  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(cgEqualizerinstanceIndexchannel);
  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(cgEqualizerinstanceIndexchannel);
  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(cgEqualizerinstanceIndexchannel);
  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(cgEqualizerinstanceIndexchannel);
  addItem( itemBand7Mute, QStringLiteral( "band7Mute" ) );
  KConfigCompilerSignallingItem  *itemBand8Mute;
  KConfigBaseEE::ItemBool  *innerItemBand8Mute;
  innerItemBand8Mute = new KConfigBaseEE::ItemBool( currentGroup(), QStringLiteral( "band8Mute" ), mBand8Mute, false );
  itemBand8Mute = new KConfigCompilerSignallingItem(innerItemBand8Mute, this, notifyFunction, signalBand8MuteChanged);
  itemBand8Mute->setWriteFlags(KConfigBase::Notify);
  itemBand8Mute->setGroup(cgEqualizerinstanceIndexchannel);
  addItem( itemBand8Mute, QStringLiteral( "band8Mute" ) );
  KConfigCompilerSignallingItem  *itemBand9Mute;
  KConfigBaseEE::ItemBool  *innerItemBand9Mute;
  innerItemBand9Mute = new KConfigBaseEE::ItemBool( currentGroup(), QStringLiteral( "band9Mute" ), mBand9Mute, false );
  itemBand9Mute = new KConfigCompilerSignallingItem(innerItemBand9Mute, this, notifyFunction, signalBand9MuteChanged);
  itemBand9Mute->setWriteFlags(KConfigBase::Notify);
  itemBand9Mute->setGroup(cgEqualizerinstanceIndexchannel);
  addItem( itemBand9Mute, QStringLiteral( "band9Mute" ) );
  KConfigCompilerSignallingItem  *itemBand10Mute;
  KConfigBaseEE::ItemBool  *innerItemBand10Mute;
  innerItemBand10Mute = new KConfigBaseEE::ItemBool( currentGroup(), QStringLiteral( "band10Mute" ), mBand10Mute, false );
  itemBand10Mute = new KConfigCompilerSignallingItem(innerItemBand10Mute, this, notifyFunction, signalBand10MuteChanged);
  itemBand10Mute->setWriteFlags(KConfigBase::Notify);
  itemBand10Mute->setGroup(cgEqualizerinstanceIndexchannel);
  addItem( itemBand10Mute, QStringLiteral( "band10Mute" ) );
  KConfigCompilerSignallingItem  *itemBand11Mute;
  KConfigBaseEE::ItemBool  *innerItemBand11Mute;
  innerItemBand11Mute = new KConfigBaseEE::ItemBool( currentGroup(), QStringLiteral( "band11Mute" ), mBand11Mute, false );
  itemBand11Mute = new KConfigCompilerSignallingItem(innerItemBand11Mute, this, notifyFunction, signalBand11MuteChanged);
  itemBand11Mute->setWriteFlags(KConfigBase::Notify);
  itemBand11Mute->setGroup(cgEqualizerinstanceIndexchannel);
  addItem( itemBand11Mute, QStringLiteral( "band11Mute" ) );
  KConfigCompilerSignallingItem  *itemBand12Mute;
  KConfigBaseEE::ItemBool  *innerItemBand12Mute;
  innerItemBand12Mute = new KConfigBaseEE::ItemBool( currentGroup(), QStringLiteral( "band12Mute" ), mBand12Mute, false );
  itemBand12Mute = new KConfigCompilerSignallingItem(innerItemBand12Mute, this, notifyFunction, signalBand12MuteChanged);
  itemBand12Mute->setWriteFlags(KConfigBase::Notify);
  itemBand12Mute->setGroup(cgEqualizerinstanceIndexchannel);
  addItem( itemBand12Mute, QStringLiteral( "band12Mute" ) );
  KConfigCompilerSignallingItem  *itemBand13Mute;
  KConfigBaseEE::ItemBool  *innerItemBand13Mute;
  innerItemBand13Mute = new KConfigBaseEE::ItemBool( currentGroup(), QStringLiteral( "band13Mute" ), mBand13Mute, false );
  itemBand13Mute = new KConfigCompilerSignallingItem(innerItemBand13Mute, this, notifyFunction, signalBand13MuteChanged);
  itemBand13Mute->setWriteFlags(KConfigBase::Notify);
  itemBand13Mute->setGroup(cgEqualizerinstanceIndexchannel);
  addItem( itemBand13Mute, QStringLiteral( "band13Mute" ) );
  KConfigCompilerSignallingItem  *itemBand14Mute;
  KConfigBaseEE::ItemBool  *innerItemBand14Mute;
  innerItemBand14Mute = new KConfigBaseEE::ItemBool( currentGroup(), QStringLiteral( "band14Mute" ), mBand14Mute, false );
  itemBand14Mute = new KConfigCompilerSignallingItem(innerItemBand14Mute, this, notifyFunction, signalBand14MuteChanged);
  itemBand14Mute->setWriteFlags(KConfigBase::Notify);
  itemBand14Mute->setGroup(cgEqualizerinstanceIndexchannel);
  addItem( itemBand14Mute, QStringLiteral( "band14Mute" ) );
  KConfigCompilerSignallingItem  *itemBand15Mute;
  KConfigBaseEE::ItemBool  *innerItemBand15Mute;
  innerItemBand15Mute = new KConfigBaseEE::ItemBool( currentGroup(), QStringLiteral( "band15Mute" ), mBand15Mute, false );
  itemBand15Mute = new KConfigCompilerSignallingItem(innerItemBand15Mute, this, notifyFunction, signalBand15MuteChanged);
  itemBand15Mute->setWriteFlags(KConfigBase::Notify);
  itemBand15Mute->setGroup(cgEqualizerinstanceIndexchannel);
  addItem( itemBand15Mute, QStringLiteral( "band15Mute" ) );
  KConfigCompilerSignallingItem  *itemBand16Mute;
  KConfigBaseEE::ItemBool  *innerItemBand16Mute;
  innerItemBand16Mute = new KConfigBaseEE::ItemBool( currentGroup(), QStringLiteral( "band16Mute" ), mBand16Mute, false );
  itemBand16Mute = new KConfigCompilerSignallingItem(innerItemBand16Mute, this, notifyFunction, signalBand16MuteChanged);
  itemBand16Mute->setWriteFlags(KConfigBase::Notify);
  itemBand16Mute->setGroup(cgEqualizerinstanceIndexchannel);
  addItem( itemBand16Mute, QStringLiteral( "band16Mute" ) );
  KConfigCompilerSignallingItem  *itemBand17Mute;
  KConfigBaseEE::ItemBool  *innerItemBand17Mute;
  innerItemBand17Mute = new KConfigBaseEE::ItemBool( currentGroup(), QStringLiteral( "band17Mute" ), mBand17Mute, false );
  itemBand17Mute = new KConfigCompilerSignallingItem(innerItemBand17Mute, this, notifyFunction, signalBand17MuteChanged);
  itemBand17Mute->setWriteFlags(KConfigBase::Notify);
  itemBand17Mute->setGroup(cgEqualizerinstanceIndexchannel);
  addItem( itemBand17Mute, QStringLiteral( "band17Mute" ) );
  KConfigCompilerSignallingItem  *itemBand18Mute;
  KConfigBaseEE::ItemBool  *innerItemBand18Mute;
  innerItemBand18Mute = new KConfigBaseEE::ItemBool( currentGroup(), QStringLiteral( "band18Mute" ), mBand18Mute, false );
  itemBand18Mute = new KConfigCompilerSignallingItem(innerItemBand18Mute, this, notifyFunction, signalBand18MuteChanged);
  itemBand18Mute->setWriteFlags(KConfigBase::Notify);
  itemBand18Mute->setGroup(cgEqualizerinstanceIndexchannel);
  addItem( itemBand18Mute, QStringLiteral( "band18Mute" ) );
  KConfigCompilerSignallingItem  *itemBand19Mute;
  KConfigBaseEE::ItemBool  *innerItemBand19Mute;
  innerItemBand19Mute = new KConfigBaseEE::ItemBool( currentGroup(), QStringLiteral( "band19Mute" ), mBand19Mute, false );
  itemBand19Mute = new KConfigCompilerSignallingItem(innerItemBand19Mute, this, notifyFunction, signalBand19MuteChanged);
  itemBand19Mute->setWriteFlags(KConfigBase::Notify);
  itemBand19Mute->setGroup(cgEqualizerinstanceIndexchannel);
  addItem( itemBand19Mute, QStringLiteral( "band19Mute" ) );
  KConfigCompilerSignallingItem  *itemBand20Mute;
  KConfigBaseEE::ItemBool  *innerItemBand20Mute;
  innerItemBand20Mute = new KConfigBaseEE::ItemBool( currentGroup(), QStringLiteral( "band20Mute" ), mBand20Mute, false );
  itemBand20Mute = new KConfigCompilerSignallingItem(innerItemBand20Mute, this, notifyFunction, signalBand20MuteChanged);
  itemBand20Mute->setWriteFlags(KConfigBase::Notify);
  itemBand20Mute->setGroup(cgEqualizerinstanceIndexchannel);
  addItem( itemBand20Mute, QStringLiteral( "band20Mute" ) );
  KConfigCompilerSignallingItem  *itemBand21Mute;
  KConfigBaseEE::ItemBool  *innerItemBand21Mute;
  innerItemBand21Mute = new KConfigBaseEE::ItemBool( currentGroup(), QStringLiteral( "band21Mute" ), mBand21Mute, false );
  itemBand21Mute = new KConfigCompilerSignallingItem(innerItemBand21Mute, this, notifyFunction, signalBand21MuteChanged);
  itemBand21Mute->setWriteFlags(KConfigBase::Notify);
  itemBand21Mute->setGroup(cgEqualizerinstanceIndexchannel);
  addItem( itemBand21Mute, QStringLiteral( "band21Mute" ) );
  KConfigCompilerSignallingItem  *itemBand22Mute;
  KConfigBaseEE::ItemBool  *innerItemBand22Mute;
  innerItemBand22Mute = new KConfigBaseEE::ItemBool( currentGroup(), QStringLiteral( "band22Mute" ), mBand22Mute, false );
  itemBand22Mute = new KConfigCompilerSignallingItem(innerItemBand22Mute, this, notifyFunction, signalBand22MuteChanged);
  itemBand22Mute->setWriteFlags(KConfigBase::Notify);
  itemBand22Mute->setGroup(cgEqualizerinstanceIndexchannel);
  addItem( itemBand22Mute, QStringLiteral( "band22Mute" ) );
  KConfigCompilerSignallingItem  *itemBand23Mute;
  KConfigBaseEE::ItemBool  *innerItemBand23Mute;
  innerItemBand23Mute = new KConfigBaseEE::ItemBool( currentGroup(), QStringLiteral( "band23Mute" ), mBand23Mute, false );
  itemBand23Mute = new KConfigCompilerSignallingItem(innerItemBand23Mute, this, notifyFunction, signalBand23MuteChanged);
  itemBand23Mute->setWriteFlags(KConfigBase::Notify);
  itemBand23Mute->setGroup(cgEqualizerinstanceIndexchannel);
  addItem( itemBand23Mute, QStringLiteral( "band23Mute" ) );
  KConfigCompilerSignallingItem  *itemBand24Mute;
  KConfigBaseEE::ItemBool  *innerItemBand24Mute;
  innerItemBand24Mute = new KConfigBaseEE::ItemBool( currentGroup(), QStringLiteral( "band24Mute" ), mBand24Mute, false );
  itemBand24Mute = new KConfigCompilerSignallingItem(innerItemBand24Mute, this, notifyFunction, signalBand24MuteChanged);
  itemBand24Mute->setWriteFlags(KConfigBase::Notify);
  itemBand24Mute->setGroup(cgEqualizerinstanceIndexchannel);
  addItem( itemBand24Mute, QStringLiteral( "band24Mute" ) );
  KConfigCompilerSignallingItem  *itemBand25Mute;
  KConfigBaseEE::ItemBool  *innerItemBand25Mute;
  innerItemBand25Mute = new KConfigBaseEE::ItemBool( currentGroup(), QStringLiteral( "band25Mute" ), mBand25Mute, false );
  itemBand25Mute = new KConfigCompilerSignallingItem(innerItemBand25Mute, this, notifyFunction, signalBand25MuteChanged);
  itemBand25Mute->setWriteFlags(KConfigBase::Notify);
  itemBand25Mute->setGroup(cgEqualizerinstanceIndexchannel);
  addItem( itemBand25Mute, QStringLiteral( "band25Mute" ) );
  KConfigCompilerSignallingItem  *itemBand26Mute;
  KConfigBaseEE::ItemBool  *innerItemBand26Mute;
  innerItemBand26Mute = new KConfigBaseEE::ItemBool( currentGroup(), QStringLiteral( "band26Mute" ), mBand26Mute, false );
  itemBand26Mute = new KConfigCompilerSignallingItem(innerItemBand26Mute, this, notifyFunction, signalBand26MuteChanged);
  itemBand26Mute->setWriteFlags(KConfigBase::Notify);
  itemBand26Mute->setGroup(cgEqualizerinstanceIndexchannel);
  addItem( itemBand26Mute, QStringLiteral( "band26Mute" ) );
  KConfigCompilerSignallingItem  *itemBand27Mute;
  KConfigBaseEE::ItemBool  *innerItemBand27Mute;
  innerItemBand27Mute = new KConfigBaseEE::ItemBool( currentGroup(), QStringLiteral( "band27Mute" ), mBand27Mute, false );
  itemBand27Mute = new KConfigCompilerSignallingItem(innerItemBand27Mute, this, notifyFunction, signalBand27MuteChanged);
  itemBand27Mute->setWriteFlags(KConfigBase::Notify);
  itemBand27Mute->setGroup(cgEqualizerinstanceIndexchannel);
  addItem( itemBand27Mute, QStringLiteral( "band27Mute" ) );
  KConfigCompilerSignallingItem  *itemBand28Mute;
  KConfigBaseEE::ItemBool  *innerItemBand28Mute;
  innerItemBand28Mute = new KConfigBaseEE::ItemBool( currentGroup(), QStringLiteral( "band28Mute" ), mBand28Mute, false );
  itemBand28Mute = new KConfigCompilerSignallingItem(innerItemBand28Mute, this, notifyFunction, signalBand28MuteChanged);
  itemBand28Mute->setWriteFlags(KConfigBase::Notify);
  itemBand28Mute->setGroup(cgEqualizerinstanceIndexchannel);
  addItem( itemBand28Mute, QStringLiteral( "band28Mute" ) );
  KConfigCompilerSignallingItem  *itemBand29Mute;
  KConfigBaseEE::ItemBool  *innerItemBand29Mute;
  innerItemBand29Mute = new KConfigBaseEE::ItemBool( currentGroup(), QStringLiteral( "band29Mute" ), mBand29Mute, false );
  itemBand29Mute = new KConfigCompilerSignallingItem(innerItemBand29Mute, this, notifyFunction, signalBand29MuteChanged);
  itemBand29Mute->setWriteFlags(KConfigBase::Notify);
  itemBand29Mute->setGroup(cgEqualizerinstanceIndexchannel);
  addItem( itemBand29Mute, QStringLiteral( "band29Mute" ) );
  KConfigCompilerSignallingItem  *itemBand30Mute;
  KConfigBaseEE::ItemBool  *innerItemBand30Mute;
  innerItemBand30Mute = new KConfigBaseEE::ItemBool( currentGroup(), QStringLiteral( "band30Mute" ), mBand30Mute, false );
  itemBand30Mute = new KConfigCompilerSignallingItem(innerItemBand30Mute, this, notifyFunction, signalBand30MuteChanged);
  itemBand30Mute->setWriteFlags(KConfigBase::Notify);
  itemBand30Mute->setGroup(cgEqualizerinstanceIndexchannel);
  addItem( itemBand30Mute, QStringLiteral( "band30Mute" ) );
  KConfigCompilerSignallingItem  *itemBand31Mute;
  KConfigBaseEE::ItemBool  *innerItemBand31Mute;
  innerItemBand31Mute = new KConfigBaseEE::ItemBool( currentGroup(), QStringLiteral( "band31Mute" ), mBand31Mute, false );
  itemBand31Mute = new KConfigCompilerSignallingItem(innerItemBand31Mute, this, notifyFunction, signalBand31MuteChanged);
  itemBand31Mute->setWriteFlags(KConfigBase::Notify);
  itemBand31Mute->setGroup(cgEqualizerinstanceIndexchannel);
  addItem( itemBand31Mute, QStringLiteral( "band31Mute" ) );
}

QStringList DbEqualizerChannel::defaultBandModeLabelsValue_helper() const
{
  QStringList defaultbandModeLabels;
  defaultbandModeLabels.append( QString::fromUtf8( "RLC (BT)" ) );
  defaultbandModeLabels.append( QString::fromUtf8( "RLC (MT)" ) );
  defaultbandModeLabels.append( QString::fromUtf8( "BWC (BT)" ) );
  defaultbandModeLabels.append( QString::fromUtf8( "BWC (MT)" ) );
  defaultbandModeLabels.append( QString::fromUtf8( "LRX (BT)" ) );
  defaultbandModeLabels.append( QString::fromUtf8( "LRX (MT)" ) );
  defaultbandModeLabels.append( QString::fromUtf8( "APO (DR)" ) );

  return defaultbandModeLabels;
}

QStringList DbEqualizerChannel::defaultBandTypeLabelsValue_helper() const
{
  QStringList defaultbandTypeLabels;
  defaultbandTypeLabels.append( QString::fromUtf8( "Off" ) );
  defaultbandTypeLabels.append( QString::fromUtf8( "Bell" ) );
  defaultbandTypeLabels.append( QString::fromUtf8( "Hi-pass" ) );
  defaultbandTypeLabels.append( QString::fromUtf8( "Hi-shelf" ) );
  defaultbandTypeLabels.append( QString::fromUtf8( "Lo-pass" ) );
  defaultbandTypeLabels.append( QString::fromUtf8( "Lo-shelf" ) );
  defaultbandTypeLabels.append( QString::fromUtf8( "Notch" ) );
  defaultbandTypeLabels.append( QString::fromUtf8( "Resonance" ) );
  defaultbandTypeLabels.append( QString::fromUtf8( "Allpass" ) );
  defaultbandTypeLabels.append( QString::fromUtf8( "Bandpass" ) );
  defaultbandTypeLabels.append( QString::fromUtf8( "Ladder-pass" ) );
  defaultbandTypeLabels.append( QString::fromUtf8( "Ladder-rej" ) );

  return defaultbandTypeLabels;
}

QStringList DbEqualizerChannel::defaultBandSlopeLabelsValue_helper() const
{
  QStringList defaultbandSlopeLabels;
  defaultbandSlopeLabels.append( QString::fromUtf8( "x1" ) );
  defaultbandSlopeLabels.append( QString::fromUtf8( "x2" ) );
  defaultbandSlopeLabels.append( QString::fromUtf8( "x3" ) );
  defaultbandSlopeLabels.append( QString::fromUtf8( "x4" ) );

  return defaultbandSlopeLabels;
}

double DbEqualizerChannel::defaultBand0GainValue_helper() const
{

  return 0;
}

double DbEqualizerChannel::defaultBand1GainValue_helper() const
{

  return 0;
}

double DbEqualizerChannel::defaultBand2GainValue_helper() const
{

  return 0;
}

double DbEqualizerChannel::defaultBand3GainValue_helper() const
{

  return 0;
}

double DbEqualizerChannel::defaultBand4GainValue_helper() const
{

  return 0;
}

double DbEqualizerChannel::defaultBand5GainValue_helper() const
{

  return 0;
}

double DbEqualizerChannel::defaultBand6GainValue_helper() const
{

  return 0;
}

double DbEqualizerChannel::defaultBand7GainValue_helper() const
{

  return 0;
}

double DbEqualizerChannel::defaultBand8GainValue_helper() const
{

  return 0;
}

double DbEqualizerChannel::defaultBand9GainValue_helper() const
{

  return 0;
}

double DbEqualizerChannel::defaultBand10GainValue_helper() const
{

  return 0;
}

double DbEqualizerChannel::defaultBand11GainValue_helper() const
{

  return 0;
}

double DbEqualizerChannel::defaultBand12GainValue_helper() const
{

  return 0;
}

double DbEqualizerChannel::defaultBand13GainValue_helper() const
{

  return 0;
}

double DbEqualizerChannel::defaultBand14GainValue_helper() const
{

  return 0;
}

double DbEqualizerChannel::defaultBand15GainValue_helper() const
{

  return 0;
}

double DbEqualizerChannel::defaultBand16GainValue_helper() const
{

  return 0;
}

double DbEqualizerChannel::defaultBand17GainValue_helper() const
{

  return 0;
}

double DbEqualizerChannel::defaultBand18GainValue_helper() const
{

  return 0;
}

double DbEqualizerChannel::defaultBand19GainValue_helper() const
{

  return 0;
}

double DbEqualizerChannel::defaultBand20GainValue_helper() const
{

  return 0;
}

double DbEqualizerChannel::defaultBand21GainValue_helper() const
{

  return 0;
}

double DbEqualizerChannel::defaultBand22GainValue_helper() const
{

  return 0;
}

double DbEqualizerChannel::defaultBand23GainValue_helper() const
{

  return 0;
}

double DbEqualizerChannel::defaultBand24GainValue_helper() const
{

  return 0;
}

double DbEqualizerChannel::defaultBand25GainValue_helper() const
{

  return 0;
}

double DbEqualizerChannel::defaultBand26GainValue_helper() const
{

  return 0;
}

double DbEqualizerChannel::defaultBand27GainValue_helper() const
{

  return 0;
}

double DbEqualizerChannel::defaultBand28GainValue_helper() const
{

  return 0;
}

double DbEqualizerChannel::defaultBand29GainValue_helper() const
{

  return 0;
}

double DbEqualizerChannel::defaultBand30GainValue_helper() const
{

  return 0;
}

double DbEqualizerChannel::defaultBand31GainValue_helper() const
{

  return 0;
}

double DbEqualizerChannel::defaultBand0FrequencyValue_helper() const
{

  return 22.40;
}

double DbEqualizerChannel::defaultBand1FrequencyValue_helper() const
{

  return 27.80;
}

double DbEqualizerChannel::defaultBand2FrequencyValue_helper() const
{

  return 34.51;
}

double DbEqualizerChannel::defaultBand3FrequencyValue_helper() const
{

  return 42.82;
}

double DbEqualizerChannel::defaultBand4FrequencyValue_helper() const
{

  return 53.14;
}

double DbEqualizerChannel::defaultBand5FrequencyValue_helper() const
{

  return 65.95;
}

double DbEqualizerChannel::defaultBand6FrequencyValue_helper() const
{

  return 81.83;
}

double DbEqualizerChannel::defaultBand7FrequencyValue_helper() const
{

  return 101.55;
}

double DbEqualizerChannel::defaultBand8FrequencyValue_helper() const
{

  return 126;
}

double DbEqualizerChannel::defaultBand9FrequencyValue_helper() const
{

  return 156.38;
}

double DbEqualizerChannel::defaultBand10FrequencyValue_helper() const
{

  return 194.06;
}

double DbEqualizerChannel::defaultBand11FrequencyValue_helper() const
{

  return 240.81;
}

double DbEqualizerChannel::defaultBand12FrequencyValue_helper() const
{

  return 298.834;
}

double DbEqualizerChannel::defaultBand13FrequencyValue_helper() const
{

  return 370.834;
}

double DbEqualizerChannel::defaultBand14FrequencyValue_helper() const
{

  return 460.182;
}

double DbEqualizerChannel::defaultBand15FrequencyValue_helper() const
{

  return 571.057;
}

double DbEqualizerChannel::defaultBand16FrequencyValue_helper() const
{

  return 708.647;
}

double DbEqualizerChannel::defaultBand17FrequencyValue_helper() const
{

  return 879.387;
}

double DbEqualizerChannel::defaultBand18FrequencyValue_helper() const
{

  return 1091.26;
}

double DbEqualizerChannel::defaultBand19FrequencyValue_helper() const
{

  return 1354.19;
}

double DbEqualizerChannel::defaultBand20FrequencyValue_helper() const
{

  return 1680.47;
}

double DbEqualizerChannel::defaultBand21FrequencyValue_helper() const
{

  return 2085.35;
}

double DbEqualizerChannel::defaultBand22FrequencyValue_helper() const
{

  return 2587.79;
}

double DbEqualizerChannel::defaultBand23FrequencyValue_helper() const
{

  return 3211.29;
}

double DbEqualizerChannel::defaultBand24FrequencyValue_helper() const
{

  return 3985.01;
}

double DbEqualizerChannel::defaultBand25FrequencyValue_helper() const
{

  return 4945.15;
}

double DbEqualizerChannel::defaultBand26FrequencyValue_helper() const
{

  return 6136.63;
}

double DbEqualizerChannel::defaultBand27FrequencyValue_helper() const
{

  return 7615.17;
}

double DbEqualizerChannel::defaultBand28FrequencyValue_helper() const
{

  return 9449.96;
}

double DbEqualizerChannel::defaultBand29FrequencyValue_helper() const
{

  return 11726.8;
}

double DbEqualizerChannel::defaultBand30FrequencyValue_helper() const
{

  return 14552.2;
}

double DbEqualizerChannel::defaultBand31FrequencyValue_helper() const
{

  return 18058.4;
}

double DbEqualizerChannel::defaultBand0QValue_helper() const
{

  return 4.36;
}

double DbEqualizerChannel::defaultBand1QValue_helper() const
{

  return 4.36;
}

double DbEqualizerChannel::defaultBand2QValue_helper() const
{

  return 4.36;
}

double DbEqualizerChannel::defaultBand3QValue_helper() const
{

  return 4.36;
}

double DbEqualizerChannel::defaultBand4QValue_helper() const
{

  return 4.36;
}

double DbEqualizerChannel::defaultBand5QValue_helper() const
{

  return 4.36;
}

double DbEqualizerChannel::defaultBand6QValue_helper() const
{

  return 4.36;
}

double DbEqualizerChannel::defaultBand7QValue_helper() const
{

  return 4.36;
}

double DbEqualizerChannel::defaultBand8QValue_helper() const
{

  return 4.36;
}

double DbEqualizerChannel::defaultBand9QValue_helper() const
{

  return 4.36;
}

double DbEqualizerChannel::defaultBand10QValue_helper() const
{

  return 4.36;
}

double DbEqualizerChannel::defaultBand11QValue_helper() const
{

  return 4.36;
}

double DbEqualizerChannel::defaultBand12QValue_helper() const
{

  return 4.36;
}

double DbEqualizerChannel::defaultBand13QValue_helper() const
{

  return 4.36;
}

double DbEqualizerChannel::defaultBand14QValue_helper() const
{

  return 4.36;
}

double DbEqualizerChannel::defaultBand15QValue_helper() const
{

  return 4.36;
}

double DbEqualizerChannel::defaultBand16QValue_helper() const
{

  return 4.36;
}

double DbEqualizerChannel::defaultBand17QValue_helper() const
{

  return 4.36;
}

double DbEqualizerChannel::defaultBand18QValue_helper() const
{

  return 4.36;
}

double DbEqualizerChannel::defaultBand19QValue_helper() const
{

  return 4.36;
}

double DbEqualizerChannel::defaultBand20QValue_helper() const
{

  return 4.36;
}

double DbEqualizerChannel::defaultBand21QValue_helper() const
{

  return 4.36;
}

double DbEqualizerChannel::defaultBand22QValue_helper() const
{

  return 4.36;
}

double DbEqualizerChannel::defaultBand23QValue_helper() const
{

  return 4.36;
}

double DbEqualizerChannel::defaultBand24QValue_helper() const
{

  return 4.36;
}

double DbEqualizerChannel::defaultBand25QValue_helper() const
{

  return 4.36;
}

double DbEqualizerChannel::defaultBand26QValue_helper() const
{

  return 4.36;
}

double DbEqualizerChannel::defaultBand27QValue_helper() const
{

  return 4.36;
}

double DbEqualizerChannel::defaultBand28QValue_helper() const
{

  return 4.36;
}

double DbEqualizerChannel::defaultBand29QValue_helper() const
{

  return 4.36;
}

double DbEqualizerChannel::defaultBand30QValue_helper() const
{

  return 4.36;
}

double DbEqualizerChannel::defaultBand31QValue_helper() const
{

  return 4.36;
}

double DbEqualizerChannel::defaultBand0WidthValue_helper() const
{

  return 4;
}

double DbEqualizerChannel::defaultBand1WidthValue_helper() const
{

  return 4;
}

double DbEqualizerChannel::defaultBand2WidthValue_helper() const
{

  return 4;
}

double DbEqualizerChannel::defaultBand3WidthValue_helper() const
{

  return 4;
}

double DbEqualizerChannel::defaultBand4WidthValue_helper() const
{

  return 4;
}

double DbEqualizerChannel::defaultBand5WidthValue_helper() const
{

  return 4;
}

double DbEqualizerChannel::defaultBand6WidthValue_helper() const
{

  return 4;
}

double DbEqualizerChannel::defaultBand7WidthValue_helper() const
{

  return 4;
}

double DbEqualizerChannel::defaultBand8WidthValue_helper() const
{

  return 4;
}

double DbEqualizerChannel::defaultBand9WidthValue_helper() const
{

  return 4;
}

double DbEqualizerChannel::defaultBand10WidthValue_helper() const
{

  return 4;
}

double DbEqualizerChannel::defaultBand11WidthValue_helper() const
{

  return 4;
}

double DbEqualizerChannel::defaultBand12WidthValue_helper() const
{

  return 4;
}

double DbEqualizerChannel::defaultBand13WidthValue_helper() const
{

  return 4;
}

double DbEqualizerChannel::defaultBand14WidthValue_helper() const
{

  return 4;
}

double DbEqualizerChannel::defaultBand15WidthValue_helper() const
{

  return 4;
}

double DbEqualizerChannel::defaultBand16WidthValue_helper() const
{

  return 4;
}

double DbEqualizerChannel::defaultBand17WidthValue_helper() const
{

  return 4;
}

double DbEqualizerChannel::defaultBand18WidthValue_helper() const
{

  return 4;
}

double DbEqualizerChannel::defaultBand19WidthValue_helper() const
{

  return 4;
}

double DbEqualizerChannel::defaultBand20WidthValue_helper() const
{

  return 4;
}

double DbEqualizerChannel::defaultBand21WidthValue_helper() const
{

  return 4;
}

double DbEqualizerChannel::defaultBand22WidthValue_helper() const
{

  return 4;
}

double DbEqualizerChannel::defaultBand23WidthValue_helper() const
{

  return 4;
}

double DbEqualizerChannel::defaultBand24WidthValue_helper() const
{

  return 4;
}

double DbEqualizerChannel::defaultBand25WidthValue_helper() const
{

  return 4;
}

double DbEqualizerChannel::defaultBand26WidthValue_helper() const
{

  return 4;
}

double DbEqualizerChannel::defaultBand27WidthValue_helper() const
{

  return 4;
}

double DbEqualizerChannel::defaultBand28WidthValue_helper() const
{

  return 4;
}

double DbEqualizerChannel::defaultBand29WidthValue_helper() const
{

  return 4;
}

double DbEqualizerChannel::defaultBand30WidthValue_helper() const
{

  return 4;
}

double DbEqualizerChannel::defaultBand31WidthValue_helper() const
{

  return 4;
}

int DbEqualizerChannel::defaultBand0TypeValue_helper() const
{

  return 1;
}

int DbEqualizerChannel::defaultBand1TypeValue_helper() const
{

  return 1;
}

int DbEqualizerChannel::defaultBand2TypeValue_helper() const
{

  return 1;
}

int DbEqualizerChannel::defaultBand3TypeValue_helper() const
{

  return 1;
}

int DbEqualizerChannel::defaultBand4TypeValue_helper() const
{

  return 1;
}

int DbEqualizerChannel::defaultBand5TypeValue_helper() const
{

  return 1;
}

int DbEqualizerChannel::defaultBand6TypeValue_helper() const
{

  return 1;
}

int DbEqualizerChannel::defaultBand7TypeValue_helper() const
{

  return 1;
}

int DbEqualizerChannel::defaultBand8TypeValue_helper() const
{

  return 1;
}

int DbEqualizerChannel::defaultBand9TypeValue_helper() const
{

  return 1;
}

int DbEqualizerChannel::defaultBand10TypeValue_helper() const
{

  return 1;
}

int DbEqualizerChannel::defaultBand11TypeValue_helper() const
{

  return 1;
}

int DbEqualizerChannel::defaultBand12TypeValue_helper() const
{

  return 1;
}

int DbEqualizerChannel::defaultBand13TypeValue_helper() const
{

  return 1;
}

int DbEqualizerChannel::defaultBand14TypeValue_helper() const
{

  return 1;
}

int DbEqualizerChannel::defaultBand15TypeValue_helper() const
{

  return 1;
}

int DbEqualizerChannel::defaultBand16TypeValue_helper() const
{

  return 1;
}

int DbEqualizerChannel::defaultBand17TypeValue_helper() const
{

  return 1;
}

int DbEqualizerChannel::defaultBand18TypeValue_helper() const
{

  return 1;
}

int DbEqualizerChannel::defaultBand19TypeValue_helper() const
{

  return 1;
}

int DbEqualizerChannel::defaultBand20TypeValue_helper() const
{

  return 1;
}

int DbEqualizerChannel::defaultBand21TypeValue_helper() const
{

  return 1;
}

int DbEqualizerChannel::defaultBand22TypeValue_helper() const
{

  return 1;
}

int DbEqualizerChannel::defaultBand23TypeValue_helper() const
{

  return 1;
}

int DbEqualizerChannel::defaultBand24TypeValue_helper() const
{

  return 1;
}

int DbEqualizerChannel::defaultBand25TypeValue_helper() const
{

  return 1;
}

int DbEqualizerChannel::defaultBand26TypeValue_helper() const
{

  return 1;
}

int DbEqualizerChannel::defaultBand27TypeValue_helper() const
{

  return 1;
}

int DbEqualizerChannel::defaultBand28TypeValue_helper() const
{

  return 1;
}

int DbEqualizerChannel::defaultBand29TypeValue_helper() const
{

  return 1;
}

int DbEqualizerChannel::defaultBand30TypeValue_helper() const
{

  return 1;
}

int DbEqualizerChannel::defaultBand31TypeValue_helper() const
{

  return 1;
}

int DbEqualizerChannel::defaultBand0ModeValue_helper() const
{

  return 0;
}

int DbEqualizerChannel::defaultBand1ModeValue_helper() const
{

  return 0;
}

int DbEqualizerChannel::defaultBand2ModeValue_helper() const
{

  return 0;
}

int DbEqualizerChannel::defaultBand3ModeValue_helper() const
{

  return 0;
}

int DbEqualizerChannel::defaultBand4ModeValue_helper() const
{

  return 0;
}

int DbEqualizerChannel::defaultBand5ModeValue_helper() const
{

  return 0;
}

int DbEqualizerChannel::defaultBand6ModeValue_helper() const
{

  return 0;
}

int DbEqualizerChannel::defaultBand7ModeValue_helper() const
{

  return 0;
}

int DbEqualizerChannel::defaultBand8ModeValue_helper() const
{

  return 0;
}

int DbEqualizerChannel::defaultBand9ModeValue_helper() const
{

  return 0;
}

int DbEqualizerChannel::defaultBand10ModeValue_helper() const
{

  return 0;
}

int DbEqualizerChannel::defaultBand11ModeValue_helper() const
{

  return 0;
}

int DbEqualizerChannel::defaultBand12ModeValue_helper() const
{

  return 0;
}

int DbEqualizerChannel::defaultBand13ModeValue_helper() const
{

  return 0;
}

int DbEqualizerChannel::defaultBand14ModeValue_helper() const
{

  return 0;
}

int DbEqualizerChannel::defaultBand15ModeValue_helper() const
{

  return 0;
}

int DbEqualizerChannel::defaultBand16ModeValue_helper() const
{

  return 0;
}

int DbEqualizerChannel::defaultBand17ModeValue_helper() const
{

  return 0;
}

int DbEqualizerChannel::defaultBand18ModeValue_helper() const
{

  return 0;
}

int DbEqualizerChannel::defaultBand19ModeValue_helper() const
{

  return 0;
}

int DbEqualizerChannel::defaultBand20ModeValue_helper() const
{

  return 0;
}

int DbEqualizerChannel::defaultBand21ModeValue_helper() const
{

  return 0;
}

int DbEqualizerChannel::defaultBand22ModeValue_helper() const
{

  return 0;
}

int DbEqualizerChannel::defaultBand23ModeValue_helper() const
{

  return 0;
}

int DbEqualizerChannel::defaultBand24ModeValue_helper() const
{

  return 0;
}

int DbEqualizerChannel::defaultBand25ModeValue_helper() const
{

  return 0;
}

int DbEqualizerChannel::defaultBand26ModeValue_helper() const
{

  return 0;
}

int DbEqualizerChannel::defaultBand27ModeValue_helper() const
{

  return 0;
}

int DbEqualizerChannel::defaultBand28ModeValue_helper() const
{

  return 0;
}

int DbEqualizerChannel::defaultBand29ModeValue_helper() const
{

  return 0;
}

int DbEqualizerChannel::defaultBand30ModeValue_helper() const
{

  return 0;
}

int DbEqualizerChannel::defaultBand31ModeValue_helper() const
{

  return 0;
}

int DbEqualizerChannel::defaultBand0SlopeValue_helper() const
{

  return 0;
}

int DbEqualizerChannel::defaultBand1SlopeValue_helper() const
{

  return 0;
}

int DbEqualizerChannel::defaultBand2SlopeValue_helper() const
{

  return 0;
}

int DbEqualizerChannel::defaultBand3SlopeValue_helper() const
{

  return 0;
}

int DbEqualizerChannel::defaultBand4SlopeValue_helper() const
{

  return 0;
}

int DbEqualizerChannel::defaultBand5SlopeValue_helper() const
{

  return 0;
}

int DbEqualizerChannel::defaultBand6SlopeValue_helper() const
{

  return 0;
}

int DbEqualizerChannel::defaultBand7SlopeValue_helper() const
{

  return 0;
}

int DbEqualizerChannel::defaultBand8SlopeValue_helper() const
{

  return 0;
}

int DbEqualizerChannel::defaultBand9SlopeValue_helper() const
{

  return 0;
}

int DbEqualizerChannel::defaultBand10SlopeValue_helper() const
{

  return 0;
}

int DbEqualizerChannel::defaultBand11SlopeValue_helper() const
{

  return 0;
}

int DbEqualizerChannel::defaultBand12SlopeValue_helper() const
{

  return 0;
}

int DbEqualizerChannel::defaultBand13SlopeValue_helper() const
{

  return 0;
}

int DbEqualizerChannel::defaultBand14SlopeValue_helper() const
{

  return 0;
}

int DbEqualizerChannel::defaultBand15SlopeValue_helper() const
{

  return 0;
}

int DbEqualizerChannel::defaultBand16SlopeValue_helper() const
{

  return 0;
}

int DbEqualizerChannel::defaultBand17SlopeValue_helper() const
{

  return 0;
}

int DbEqualizerChannel::defaultBand18SlopeValue_helper() const
{

  return 0;
}

int DbEqualizerChannel::defaultBand19SlopeValue_helper() const
{

  return 0;
}

int DbEqualizerChannel::defaultBand20SlopeValue_helper() const
{

  return 0;
}

int DbEqualizerChannel::defaultBand21SlopeValue_helper() const
{

  return 0;
}

int DbEqualizerChannel::defaultBand22SlopeValue_helper() const
{

  return 0;
}

int DbEqualizerChannel::defaultBand23SlopeValue_helper() const
{

  return 0;
}

int DbEqualizerChannel::defaultBand24SlopeValue_helper() const
{

  return 0;
}

int DbEqualizerChannel::defaultBand25SlopeValue_helper() const
{

  return 0;
}

int DbEqualizerChannel::defaultBand26SlopeValue_helper() const
{

  return 0;
}

int DbEqualizerChannel::defaultBand27SlopeValue_helper() const
{

  return 0;
}

int DbEqualizerChannel::defaultBand28SlopeValue_helper() const
{

  return 0;
}

int DbEqualizerChannel::defaultBand29SlopeValue_helper() const
{

  return 0;
}

int DbEqualizerChannel::defaultBand30SlopeValue_helper() const
{

  return 0;
}

int DbEqualizerChannel::defaultBand31SlopeValue_helper() const
{

  return 0;
}

bool DbEqualizerChannel::defaultBand0SoloValue_helper() const
{

  return false;
}

bool DbEqualizerChannel::defaultBand1SoloValue_helper() const
{

  return false;
}

bool DbEqualizerChannel::defaultBand2SoloValue_helper() const
{

  return false;
}

bool DbEqualizerChannel::defaultBand3SoloValue_helper() const
{

  return false;
}

bool DbEqualizerChannel::defaultBand4SoloValue_helper() const
{

  return false;
}

bool DbEqualizerChannel::defaultBand5SoloValue_helper() const
{

  return false;
}

bool DbEqualizerChannel::defaultBand6SoloValue_helper() const
{

  return false;
}

bool DbEqualizerChannel::defaultBand7SoloValue_helper() const
{

  return false;
}

bool DbEqualizerChannel::defaultBand8SoloValue_helper() const
{

  return false;
}

bool DbEqualizerChannel::defaultBand9SoloValue_helper() const
{

  return false;
}

bool DbEqualizerChannel::defaultBand10SoloValue_helper() const
{

  return false;
}

bool DbEqualizerChannel::defaultBand11SoloValue_helper() const
{

  return false;
}

bool DbEqualizerChannel::defaultBand12SoloValue_helper() const
{

  return false;
}

bool DbEqualizerChannel::defaultBand13SoloValue_helper() const
{

  return false;
}

bool DbEqualizerChannel::defaultBand14SoloValue_helper() const
{

  return false;
}

bool DbEqualizerChannel::defaultBand15SoloValue_helper() const
{

  return false;
}

bool DbEqualizerChannel::defaultBand16SoloValue_helper() const
{

  return false;
}

bool DbEqualizerChannel::defaultBand17SoloValue_helper() const
{

  return false;
}

bool DbEqualizerChannel::defaultBand18SoloValue_helper() const
{

  return false;
}

bool DbEqualizerChannel::defaultBand19SoloValue_helper() const
{

  return false;
}

bool DbEqualizerChannel::defaultBand20SoloValue_helper() const
{

  return false;
}

bool DbEqualizerChannel::defaultBand21SoloValue_helper() const
{

  return false;
}

bool DbEqualizerChannel::defaultBand22SoloValue_helper() const
{

  return false;
}

bool DbEqualizerChannel::defaultBand23SoloValue_helper() const
{

  return false;
}

bool DbEqualizerChannel::defaultBand24SoloValue_helper() const
{

  return false;
}

bool DbEqualizerChannel::defaultBand25SoloValue_helper() const
{

  return false;
}

bool DbEqualizerChannel::defaultBand26SoloValue_helper() const
{

  return false;
}

bool DbEqualizerChannel::defaultBand27SoloValue_helper() const
{

  return false;
}

bool DbEqualizerChannel::defaultBand28SoloValue_helper() const
{

  return false;
}

bool DbEqualizerChannel::defaultBand29SoloValue_helper() const
{

  return false;
}

bool DbEqualizerChannel::defaultBand30SoloValue_helper() const
{

  return false;
}

bool DbEqualizerChannel::defaultBand31SoloValue_helper() const
{

  return false;
}

bool DbEqualizerChannel::defaultBand0MuteValue_helper() const
{

  return false;
}

bool DbEqualizerChannel::defaultBand1MuteValue_helper() const
{

  return false;
}

bool DbEqualizerChannel::defaultBand2MuteValue_helper() const
{

  return false;
}

bool DbEqualizerChannel::defaultBand3MuteValue_helper() const
{

  return false;
}

bool DbEqualizerChannel::defaultBand4MuteValue_helper() const
{

  return false;
}

bool DbEqualizerChannel::defaultBand5MuteValue_helper() const
{

  return false;
}

bool DbEqualizerChannel::defaultBand6MuteValue_helper() const
{

  return false;
}

bool DbEqualizerChannel::defaultBand7MuteValue_helper() const
{

  return false;
}

bool DbEqualizerChannel::defaultBand8MuteValue_helper() const
{

  return false;
}

bool DbEqualizerChannel::defaultBand9MuteValue_helper() const
{

  return false;
}

bool DbEqualizerChannel::defaultBand10MuteValue_helper() const
{

  return false;
}

bool DbEqualizerChannel::defaultBand11MuteValue_helper() const
{

  return false;
}

bool DbEqualizerChannel::defaultBand12MuteValue_helper() const
{

  return false;
}

bool DbEqualizerChannel::defaultBand13MuteValue_helper() const
{

  return false;
}

bool DbEqualizerChannel::defaultBand14MuteValue_helper() const
{

  return false;
}

bool DbEqualizerChannel::defaultBand15MuteValue_helper() const
{

  return false;
}

bool DbEqualizerChannel::defaultBand16MuteValue_helper() const
{

  return false;
}

bool DbEqualizerChannel::defaultBand17MuteValue_helper() const
{

  return false;
}

bool DbEqualizerChannel::defaultBand18MuteValue_helper() const
{

  return false;
}

bool DbEqualizerChannel::defaultBand19MuteValue_helper() const
{

  return false;
}

bool DbEqualizerChannel::defaultBand20MuteValue_helper() const
{

  return false;
}

bool DbEqualizerChannel::defaultBand21MuteValue_helper() const
{

  return false;
}

bool DbEqualizerChannel::defaultBand22MuteValue_helper() const
{

  return false;
}

bool DbEqualizerChannel::defaultBand23MuteValue_helper() const
{

  return false;
}

bool DbEqualizerChannel::defaultBand24MuteValue_helper() const
{

  return false;
}

bool DbEqualizerChannel::defaultBand25MuteValue_helper() const
{

  return false;
}

bool DbEqualizerChannel::defaultBand26MuteValue_helper() const
{

  return false;
}

bool DbEqualizerChannel::defaultBand27MuteValue_helper() const
{

  return false;
}

bool DbEqualizerChannel::defaultBand28MuteValue_helper() const
{

  return false;
}

bool DbEqualizerChannel::defaultBand29MuteValue_helper() const
{

  return false;
}

bool DbEqualizerChannel::defaultBand30MuteValue_helper() const
{

  return false;
}

bool DbEqualizerChannel::defaultBand31MuteValue_helper() const
{

  return false;
}

DbEqualizerChannel::~DbEqualizerChannel()
{
}


void DbEqualizerChannel::itemChanged(quint64 signalFlag) {

  switch (signalFlag) {
  case signalBandModeLabelsChanged:
    Q_EMIT bandModeLabelsChanged();
    break;
  case signalBandTypeLabelsChanged:
    Q_EMIT bandTypeLabelsChanged();
    break;
  case signalBandSlopeLabelsChanged:
    Q_EMIT bandSlopeLabelsChanged();
    break;
  case signalBand0GainChanged:
    Q_EMIT band0GainChanged();
    break;
  case signalBand1GainChanged:
    Q_EMIT band1GainChanged();
    break;
  case signalBand2GainChanged:
    Q_EMIT band2GainChanged();
    break;
  case signalBand3GainChanged:
    Q_EMIT band3GainChanged();
    break;
  case signalBand4GainChanged:
    Q_EMIT band4GainChanged();
    break;
  case signalBand5GainChanged:
    Q_EMIT band5GainChanged();
    break;
  case signalBand6GainChanged:
    Q_EMIT band6GainChanged();
    break;
  case signalBand7GainChanged:
    Q_EMIT band7GainChanged();
    break;
  case signalBand8GainChanged:
    Q_EMIT band8GainChanged();
    break;
  case signalBand9GainChanged:
    Q_EMIT band9GainChanged();
    break;
  case signalBand10GainChanged:
    Q_EMIT band10GainChanged();
    break;
  case signalBand11GainChanged:
    Q_EMIT band11GainChanged();
    break;
  case signalBand12GainChanged:
    Q_EMIT band12GainChanged();
    break;
  case signalBand13GainChanged:
    Q_EMIT band13GainChanged();
    break;
  case signalBand14GainChanged:
    Q_EMIT band14GainChanged();
    break;
  case signalBand15GainChanged:
    Q_EMIT band15GainChanged();
    break;
  case signalBand16GainChanged:
    Q_EMIT band16GainChanged();
    break;
  case signalBand17GainChanged:
    Q_EMIT band17GainChanged();
    break;
  case signalBand18GainChanged:
    Q_EMIT band18GainChanged();
    break;
  case signalBand19GainChanged:
    Q_EMIT band19GainChanged();
    break;
  case signalBand20GainChanged:
    Q_EMIT band20GainChanged();
    break;
  case signalBand21GainChanged:
    Q_EMIT band21GainChanged();
    break;
  case signalBand22GainChanged:
    Q_EMIT band22GainChanged();
    break;
  case signalBand23GainChanged:
    Q_EMIT band23GainChanged();
    break;
  case signalBand24GainChanged:
    Q_EMIT band24GainChanged();
    break;
  case signalBand25GainChanged:
    Q_EMIT band25GainChanged();
    break;
  case signalBand26GainChanged:
    Q_EMIT band26GainChanged();
    break;
  case signalBand27GainChanged:
    Q_EMIT band27GainChanged();
    break;
  case signalBand28GainChanged:
    Q_EMIT band28GainChanged();
    break;
  case signalBand29GainChanged:
    Q_EMIT band29GainChanged();
    break;
  case signalBand30GainChanged:
    Q_EMIT band30GainChanged();
    break;
  case signalBand31GainChanged:
    Q_EMIT band31GainChanged();
    break;
  case signalBand0FrequencyChanged:
    Q_EMIT band0FrequencyChanged();
    break;
  case signalBand1FrequencyChanged:
    Q_EMIT band1FrequencyChanged();
    break;
  case signalBand2FrequencyChanged:
    Q_EMIT band2FrequencyChanged();
    break;
  case signalBand3FrequencyChanged:
    Q_EMIT band3FrequencyChanged();
    break;
  case signalBand4FrequencyChanged:
    Q_EMIT band4FrequencyChanged();
    break;
  case signalBand5FrequencyChanged:
    Q_EMIT band5FrequencyChanged();
    break;
  case signalBand6FrequencyChanged:
    Q_EMIT band6FrequencyChanged();
    break;
  case signalBand7FrequencyChanged:
    Q_EMIT band7FrequencyChanged();
    break;
  case signalBand8FrequencyChanged:
    Q_EMIT band8FrequencyChanged();
    break;
  case signalBand9FrequencyChanged:
    Q_EMIT band9FrequencyChanged();
    break;
  case signalBand10FrequencyChanged:
    Q_EMIT band10FrequencyChanged();
    break;
  case signalBand11FrequencyChanged:
    Q_EMIT band11FrequencyChanged();
    break;
  case signalBand12FrequencyChanged:
    Q_EMIT band12FrequencyChanged();
    break;
  case signalBand13FrequencyChanged:
    Q_EMIT band13FrequencyChanged();
    break;
  case signalBand14FrequencyChanged:
    Q_EMIT band14FrequencyChanged();
    break;
  case signalBand15FrequencyChanged:
    Q_EMIT band15FrequencyChanged();
    break;
  case signalBand16FrequencyChanged:
    Q_EMIT band16FrequencyChanged();
    break;
  case signalBand17FrequencyChanged:
    Q_EMIT band17FrequencyChanged();
    break;
  case signalBand18FrequencyChanged:
    Q_EMIT band18FrequencyChanged();
    break;
  case signalBand19FrequencyChanged:
    Q_EMIT band19FrequencyChanged();
    break;
  case signalBand20FrequencyChanged:
    Q_EMIT band20FrequencyChanged();
    break;
  case signalBand21FrequencyChanged:
    Q_EMIT band21FrequencyChanged();
    break;
  case signalBand22FrequencyChanged:
    Q_EMIT band22FrequencyChanged();
    break;
  case signalBand23FrequencyChanged:
    Q_EMIT band23FrequencyChanged();
    break;
  case signalBand24FrequencyChanged:
    Q_EMIT band24FrequencyChanged();
    break;
  case signalBand25FrequencyChanged:
    Q_EMIT band25FrequencyChanged();
    break;
  case signalBand26FrequencyChanged:
    Q_EMIT band26FrequencyChanged();
    break;
  case signalBand27FrequencyChanged:
    Q_EMIT band27FrequencyChanged();
    break;
  case signalBand28FrequencyChanged:
    Q_EMIT band28FrequencyChanged();
    break;
  case signalBand29FrequencyChanged:
    Q_EMIT band29FrequencyChanged();
    break;
  case signalBand30FrequencyChanged:
    Q_EMIT band30FrequencyChanged();
    break;
  case signalBand31FrequencyChanged:
    Q_EMIT band31FrequencyChanged();
    break;
  case signalBand0QChanged:
    Q_EMIT band0QChanged();
    break;
  case signalBand1QChanged:
    Q_EMIT band1QChanged();
    break;
  case signalBand2QChanged:
    Q_EMIT band2QChanged();
    break;
  case signalBand3QChanged:
    Q_EMIT band3QChanged();
    break;
  case signalBand4QChanged:
    Q_EMIT band4QChanged();
    break;
  case signalBand5QChanged:
    Q_EMIT band5QChanged();
    break;
  case signalBand6QChanged:
    Q_EMIT band6QChanged();
    break;
  case signalBand7QChanged:
    Q_EMIT band7QChanged();
    break;
  case signalBand8QChanged:
    Q_EMIT band8QChanged();
    break;
  case signalBand9QChanged:
    Q_EMIT band9QChanged();
    break;
  case signalBand10QChanged:
    Q_EMIT band10QChanged();
    break;
  case signalBand11QChanged:
    Q_EMIT band11QChanged();
    break;
  case signalBand12QChanged:
    Q_EMIT band12QChanged();
    break;
  case signalBand13QChanged:
    Q_EMIT band13QChanged();
    break;
  case signalBand14QChanged:
    Q_EMIT band14QChanged();
    break;
  case signalBand15QChanged:
    Q_EMIT band15QChanged();
    break;
  case signalBand16QChanged:
    Q_EMIT band16QChanged();
    break;
  case signalBand17QChanged:
    Q_EMIT band17QChanged();
    break;
  case signalBand18QChanged:
    Q_EMIT band18QChanged();
    break;
  case signalBand19QChanged:
    Q_EMIT band19QChanged();
    break;
  case signalBand20QChanged:
    Q_EMIT band20QChanged();
    break;
  case signalBand21QChanged:
    Q_EMIT band21QChanged();
    break;
  case signalBand22QChanged:
    Q_EMIT band22QChanged();
    break;
  case signalBand23QChanged:
    Q_EMIT band23QChanged();
    break;
  case signalBand24QChanged:
    Q_EMIT band24QChanged();
    break;
  case signalBand25QChanged:
    Q_EMIT band25QChanged();
    break;
  case signalBand26QChanged:
    Q_EMIT band26QChanged();
    break;
  case signalBand27QChanged:
    Q_EMIT band27QChanged();
    break;
  case signalBand28QChanged:
    Q_EMIT band28QChanged();
    break;
  case signalBand29QChanged:
    Q_EMIT band29QChanged();
    break;
  case signalBand30QChanged:
    Q_EMIT band30QChanged();
    break;
  case signalBand31QChanged:
    Q_EMIT band31QChanged();
    break;
  case signalBand0WidthChanged:
    Q_EMIT band0WidthChanged();
    break;
  case signalBand1WidthChanged:
    Q_EMIT band1WidthChanged();
    break;
  case signalBand2WidthChanged:
    Q_EMIT band2WidthChanged();
    break;
  case signalBand3WidthChanged:
    Q_EMIT band3WidthChanged();
    break;
  case signalBand4WidthChanged:
    Q_EMIT band4WidthChanged();
    break;
  case signalBand5WidthChanged:
    Q_EMIT band5WidthChanged();
    break;
  case signalBand6WidthChanged:
    Q_EMIT band6WidthChanged();
    break;
  case signalBand7WidthChanged:
    Q_EMIT band7WidthChanged();
    break;
  case signalBand8WidthChanged:
    Q_EMIT band8WidthChanged();
    break;
  case signalBand9WidthChanged:
    Q_EMIT band9WidthChanged();
    break;
  case signalBand10WidthChanged:
    Q_EMIT band10WidthChanged();
    break;
  case signalBand11WidthChanged:
    Q_EMIT band11WidthChanged();
    break;
  case signalBand12WidthChanged:
    Q_EMIT band12WidthChanged();
    break;
  case signalBand13WidthChanged:
    Q_EMIT band13WidthChanged();
    break;
  case signalBand14WidthChanged:
    Q_EMIT band14WidthChanged();
    break;
  case signalBand15WidthChanged:
    Q_EMIT band15WidthChanged();
    break;
  case signalBand16WidthChanged:
    Q_EMIT band16WidthChanged();
    break;
  case signalBand17WidthChanged:
    Q_EMIT band17WidthChanged();
    break;
  case signalBand18WidthChanged:
    Q_EMIT band18WidthChanged();
    break;
  case signalBand19WidthChanged:
    Q_EMIT band19WidthChanged();
    break;
  case signalBand20WidthChanged:
    Q_EMIT band20WidthChanged();
    break;
  case signalBand21WidthChanged:
    Q_EMIT band21WidthChanged();
    break;
  case signalBand22WidthChanged:
    Q_EMIT band22WidthChanged();
    break;
  case signalBand23WidthChanged:
    Q_EMIT band23WidthChanged();
    break;
  case signalBand24WidthChanged:
    Q_EMIT band24WidthChanged();
    break;
  case signalBand25WidthChanged:
    Q_EMIT band25WidthChanged();
    break;
  case signalBand26WidthChanged:
    Q_EMIT band26WidthChanged();
    break;
  case signalBand27WidthChanged:
    Q_EMIT band27WidthChanged();
    break;
  case signalBand28WidthChanged:
    Q_EMIT band28WidthChanged();
    break;
  case signalBand29WidthChanged:
    Q_EMIT band29WidthChanged();
    break;
  case signalBand30WidthChanged:
    Q_EMIT band30WidthChanged();
    break;
  case signalBand31WidthChanged:
    Q_EMIT band31WidthChanged();
    break;
  case signalBand0TypeChanged:
    Q_EMIT band0TypeChanged();
    break;
  case signalBand1TypeChanged:
    Q_EMIT band1TypeChanged();
    break;
  case signalBand2TypeChanged:
    Q_EMIT band2TypeChanged();
    break;
  case signalBand3TypeChanged:
    Q_EMIT band3TypeChanged();
    break;
  case signalBand4TypeChanged:
    Q_EMIT band4TypeChanged();
    break;
  case signalBand5TypeChanged:
    Q_EMIT band5TypeChanged();
    break;
  case signalBand6TypeChanged:
    Q_EMIT band6TypeChanged();
    break;
  case signalBand7TypeChanged:
    Q_EMIT band7TypeChanged();
    break;
  case signalBand8TypeChanged:
    Q_EMIT band8TypeChanged();
    break;
  case signalBand9TypeChanged:
    Q_EMIT band9TypeChanged();
    break;
  case signalBand10TypeChanged:
    Q_EMIT band10TypeChanged();
    break;
  case signalBand11TypeChanged:
    Q_EMIT band11TypeChanged();
    break;
  case signalBand12TypeChanged:
    Q_EMIT band12TypeChanged();
    break;
  case signalBand13TypeChanged:
    Q_EMIT band13TypeChanged();
    break;
  case signalBand14TypeChanged:
    Q_EMIT band14TypeChanged();
    break;
  case signalBand15TypeChanged:
    Q_EMIT band15TypeChanged();
    break;
  case signalBand16TypeChanged:
    Q_EMIT band16TypeChanged();
    break;
  case signalBand17TypeChanged:
    Q_EMIT band17TypeChanged();
    break;
  case signalBand18TypeChanged:
    Q_EMIT band18TypeChanged();
    break;
  case signalBand19TypeChanged:
    Q_EMIT band19TypeChanged();
    break;
  case signalBand20TypeChanged:
    Q_EMIT band20TypeChanged();
    break;
  case signalBand21TypeChanged:
    Q_EMIT band21TypeChanged();
    break;
  case signalBand22TypeChanged:
    Q_EMIT band22TypeChanged();
    break;
  case signalBand23TypeChanged:
    Q_EMIT band23TypeChanged();
    break;
  case signalBand24TypeChanged:
    Q_EMIT band24TypeChanged();
    break;
  case signalBand25TypeChanged:
    Q_EMIT band25TypeChanged();
    break;
  case signalBand26TypeChanged:
    Q_EMIT band26TypeChanged();
    break;
  case signalBand27TypeChanged:
    Q_EMIT band27TypeChanged();
    break;
  case signalBand28TypeChanged:
    Q_EMIT band28TypeChanged();
    break;
  case signalBand29TypeChanged:
    Q_EMIT band29TypeChanged();
    break;
  case signalBand30TypeChanged:
    Q_EMIT band30TypeChanged();
    break;
  case signalBand31TypeChanged:
    Q_EMIT band31TypeChanged();
    break;
  case signalBand0ModeChanged:
    Q_EMIT band0ModeChanged();
    break;
  case signalBand1ModeChanged:
    Q_EMIT band1ModeChanged();
    break;
  case signalBand2ModeChanged:
    Q_EMIT band2ModeChanged();
    break;
  case signalBand3ModeChanged:
    Q_EMIT band3ModeChanged();
    break;
  case signalBand4ModeChanged:
    Q_EMIT band4ModeChanged();
    break;
  case signalBand5ModeChanged:
    Q_EMIT band5ModeChanged();
    break;
  case signalBand6ModeChanged:
    Q_EMIT band6ModeChanged();
    break;
  case signalBand7ModeChanged:
    Q_EMIT band7ModeChanged();
    break;
  case signalBand8ModeChanged:
    Q_EMIT band8ModeChanged();
    break;
  case signalBand9ModeChanged:
    Q_EMIT band9ModeChanged();
    break;
  case signalBand10ModeChanged:
    Q_EMIT band10ModeChanged();
    break;
  case signalBand11ModeChanged:
    Q_EMIT band11ModeChanged();
    break;
  case signalBand12ModeChanged:
    Q_EMIT band12ModeChanged();
    break;
  case signalBand13ModeChanged:
    Q_EMIT band13ModeChanged();
    break;
  case signalBand14ModeChanged:
    Q_EMIT band14ModeChanged();
    break;
  case signalBand15ModeChanged:
    Q_EMIT band15ModeChanged();
    break;
  case signalBand16ModeChanged:
    Q_EMIT band16ModeChanged();
    break;
  case signalBand17ModeChanged:
    Q_EMIT band17ModeChanged();
    break;
  case signalBand18ModeChanged:
    Q_EMIT band18ModeChanged();
    break;
  case signalBand19ModeChanged:
    Q_EMIT band19ModeChanged();
    break;
  case signalBand20ModeChanged:
    Q_EMIT band20ModeChanged();
    break;
  case signalBand21ModeChanged:
    Q_EMIT band21ModeChanged();
    break;
  case signalBand22ModeChanged:
    Q_EMIT band22ModeChanged();
    break;
  case signalBand23ModeChanged:
    Q_EMIT band23ModeChanged();
    break;
  case signalBand24ModeChanged:
    Q_EMIT band24ModeChanged();
    break;
  case signalBand25ModeChanged:
    Q_EMIT band25ModeChanged();
    break;
  case signalBand26ModeChanged:
    Q_EMIT band26ModeChanged();
    break;
  case signalBand27ModeChanged:
    Q_EMIT band27ModeChanged();
    break;
  case signalBand28ModeChanged:
    Q_EMIT band28ModeChanged();
    break;
  case signalBand29ModeChanged:
    Q_EMIT band29ModeChanged();
    break;
  case signalBand30ModeChanged:
    Q_EMIT band30ModeChanged();
    break;
  case signalBand31ModeChanged:
    Q_EMIT band31ModeChanged();
    break;
  case signalBand0SlopeChanged:
    Q_EMIT band0SlopeChanged();
    break;
  case signalBand1SlopeChanged:
    Q_EMIT band1SlopeChanged();
    break;
  case signalBand2SlopeChanged:
    Q_EMIT band2SlopeChanged();
    break;
  case signalBand3SlopeChanged:
    Q_EMIT band3SlopeChanged();
    break;
  case signalBand4SlopeChanged:
    Q_EMIT band4SlopeChanged();
    break;
  case signalBand5SlopeChanged:
    Q_EMIT band5SlopeChanged();
    break;
  case signalBand6SlopeChanged:
    Q_EMIT band6SlopeChanged();
    break;
  case signalBand7SlopeChanged:
    Q_EMIT band7SlopeChanged();
    break;
  case signalBand8SlopeChanged:
    Q_EMIT band8SlopeChanged();
    break;
  case signalBand9SlopeChanged:
    Q_EMIT band9SlopeChanged();
    break;
  case signalBand10SlopeChanged:
    Q_EMIT band10SlopeChanged();
    break;
  case signalBand11SlopeChanged:
    Q_EMIT band11SlopeChanged();
    break;
  case signalBand12SlopeChanged:
    Q_EMIT band12SlopeChanged();
    break;
  case signalBand13SlopeChanged:
    Q_EMIT band13SlopeChanged();
    break;
  case signalBand14SlopeChanged:
    Q_EMIT band14SlopeChanged();
    break;
  case signalBand15SlopeChanged:
    Q_EMIT band15SlopeChanged();
    break;
  case signalBand16SlopeChanged:
    Q_EMIT band16SlopeChanged();
    break;
  case signalBand17SlopeChanged:
    Q_EMIT band17SlopeChanged();
    break;
  case signalBand18SlopeChanged:
    Q_EMIT band18SlopeChanged();
    break;
  case signalBand19SlopeChanged:
    Q_EMIT band19SlopeChanged();
    break;
  case signalBand20SlopeChanged:
    Q_EMIT band20SlopeChanged();
    break;
  case signalBand21SlopeChanged:
    Q_EMIT band21SlopeChanged();
    break;
  case signalBand22SlopeChanged:
    Q_EMIT band22SlopeChanged();
    break;
  case signalBand23SlopeChanged:
    Q_EMIT band23SlopeChanged();
    break;
  case signalBand24SlopeChanged:
    Q_EMIT band24SlopeChanged();
    break;
  case signalBand25SlopeChanged:
    Q_EMIT band25SlopeChanged();
    break;
  case signalBand26SlopeChanged:
    Q_EMIT band26SlopeChanged();
    break;
  case signalBand27SlopeChanged:
    Q_EMIT band27SlopeChanged();
    break;
  case signalBand28SlopeChanged:
    Q_EMIT band28SlopeChanged();
    break;
  case signalBand29SlopeChanged:
    Q_EMIT band29SlopeChanged();
    break;
  case signalBand30SlopeChanged:
    Q_EMIT band30SlopeChanged();
    break;
  case signalBand31SlopeChanged:
    Q_EMIT band31SlopeChanged();
    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 signalBand8SoloChanged:
    Q_EMIT band8SoloChanged();
    break;
  case signalBand9SoloChanged:
    Q_EMIT band9SoloChanged();
    break;
  case signalBand10SoloChanged:
    Q_EMIT band10SoloChanged();
    break;
  case signalBand11SoloChanged:
    Q_EMIT band11SoloChanged();
    break;
  case signalBand12SoloChanged:
    Q_EMIT band12SoloChanged();
    break;
  case signalBand13SoloChanged:
    Q_EMIT band13SoloChanged();
    break;
  case signalBand14SoloChanged:
    Q_EMIT band14SoloChanged();
    break;
  case signalBand15SoloChanged:
    Q_EMIT band15SoloChanged();
    break;
  case signalBand16SoloChanged:
    Q_EMIT band16SoloChanged();
    break;
  case signalBand17SoloChanged:
    Q_EMIT band17SoloChanged();
    break;
  case signalBand18SoloChanged:
    Q_EMIT band18SoloChanged();
    break;
  case signalBand19SoloChanged:
    Q_EMIT band19SoloChanged();
    break;
  case signalBand20SoloChanged:
    Q_EMIT band20SoloChanged();
    break;
  case signalBand21SoloChanged:
    Q_EMIT band21SoloChanged();
    break;
  case signalBand22SoloChanged:
    Q_EMIT band22SoloChanged();
    break;
  case signalBand23SoloChanged:
    Q_EMIT band23SoloChanged();
    break;
  case signalBand24SoloChanged:
    Q_EMIT band24SoloChanged();
    break;
  case signalBand25SoloChanged:
    Q_EMIT band25SoloChanged();
    break;
  case signalBand26SoloChanged:
    Q_EMIT band26SoloChanged();
    break;
  case signalBand27SoloChanged:
    Q_EMIT band27SoloChanged();
    break;
  case signalBand28SoloChanged:
    Q_EMIT band28SoloChanged();
    break;
  case signalBand29SoloChanged:
    Q_EMIT band29SoloChanged();
    break;
  case signalBand30SoloChanged:
    Q_EMIT band30SoloChanged();
    break;
  case signalBand31SoloChanged:
    Q_EMIT band31SoloChanged();
    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 signalBand8MuteChanged:
    Q_EMIT band8MuteChanged();
    break;
  case signalBand9MuteChanged:
    Q_EMIT band9MuteChanged();
    break;
  case signalBand10MuteChanged:
    Q_EMIT band10MuteChanged();
    break;
  case signalBand11MuteChanged:
    Q_EMIT band11MuteChanged();
    break;
  case signalBand12MuteChanged:
    Q_EMIT band12MuteChanged();
    break;
  case signalBand13MuteChanged:
    Q_EMIT band13MuteChanged();
    break;
  case signalBand14MuteChanged:
    Q_EMIT band14MuteChanged();
    break;
  case signalBand15MuteChanged:
    Q_EMIT band15MuteChanged();
    break;
  case signalBand16MuteChanged:
    Q_EMIT band16MuteChanged();
    break;
  case signalBand17MuteChanged:
    Q_EMIT band17MuteChanged();
    break;
  case signalBand18MuteChanged:
    Q_EMIT band18MuteChanged();
    break;
  case signalBand19MuteChanged:
    Q_EMIT band19MuteChanged();
    break;
  case signalBand20MuteChanged:
    Q_EMIT band20MuteChanged();
    break;
  case signalBand21MuteChanged:
    Q_EMIT band21MuteChanged();
    break;
  case signalBand22MuteChanged:
    Q_EMIT band22MuteChanged();
    break;
  case signalBand23MuteChanged:
    Q_EMIT band23MuteChanged();
    break;
  case signalBand24MuteChanged:
    Q_EMIT band24MuteChanged();
    break;
  case signalBand25MuteChanged:
    Q_EMIT band25MuteChanged();
    break;
  case signalBand26MuteChanged:
    Q_EMIT band26MuteChanged();
    break;
  case signalBand27MuteChanged:
    Q_EMIT band27MuteChanged();
    break;
  case signalBand28MuteChanged:
    Q_EMIT band28MuteChanged();
    break;
  case signalBand29MuteChanged:
    Q_EMIT band29MuteChanged();
    break;
  case signalBand30MuteChanged:
    Q_EMIT band30MuteChanged();
    break;
  case signalBand31MuteChanged:
    Q_EMIT band31MuteChanged();
    break;
  }
}
