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

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

class Prefs : public KConfigSkeleton
{
  Q_OBJECT
  public:
    class EnumIsotopeTableMode
    {
      public:
      enum type { isotopeTableMode_0, isotopeTableMode_1, isotopeTableMode_2, isotopeTableMode_3, COUNT };
    };

    static Prefs *self();
    ~Prefs() override;

    /**
      Set Selects the PSE
    */
    static
    void setSchemaPSE( int v )
    {
      if (!self()->isSchemaPSEImmutable())
        self()->mSchemaPSE = v;
    }

    /**
      Get Selects the PSE
    */
    static
    int schemaPSE()
    {
      return self()->mSchemaPSE;
    }

    /**
      Is Selects the PSE Immutable
    */
    static
    bool isSchemaPSEImmutable()
    {
      return self()->isImmutable( QStringLiteral( "schemaPSE" ) );
    }

    /**
      Get Selects the PSE default value
    */
    static
    int defaultSchemaPSEValue()
    {
        return defaultSchemaPSEValue_helper();
    }

    /**
      Set Selects the default color scheme
    */
    static
    void setColorschemebox( int v )
    {
      if (!self()->isColorschemeboxImmutable())
        self()->mColorschemebox = v;
    }

    /**
      Get Selects the default color scheme
    */
    static
    int colorschemebox()
    {
      return self()->mColorschemebox;
    }

    /**
      Is Selects the default color scheme Immutable
    */
    static
    bool isColorschemeboxImmutable()
    {
      return self()->isImmutable( QStringLiteral( "colorschemebox" ) );
    }

    /**
      Get Selects the default color scheme default value
    */
    static
    int defaultColorschemeboxValue()
    {
        return defaultColorschemeboxValue_helper();
    }

    /**
      Set Selects the default gradient
    */
    static
    void setGradient( int v )
    {
      if (!self()->isGradientImmutable())
        self()->mGradient = v;
    }

    /**
      Get Selects the default gradient
    */
    static
    int gradient()
    {
      return self()->mGradient;
    }

    /**
      Is Selects the default gradient Immutable
    */
    static
    bool isGradientImmutable()
    {
      return self()->isImmutable( QStringLiteral( "gradient" ) );
    }

    /**
      Get Selects the default gradient default value
    */
    static
    int defaultGradientValue()
    {
        return defaultGradientValue_helper();
    }

    /**
      Set Selects the default numeration (IUPAC)
    */
    static
    void setNumeration( int v )
    {
      if (!self()->isNumerationImmutable())
        self()->mNumeration = v;
    }

    /**
      Get Selects the default numeration (IUPAC)
    */
    static
    int numeration()
    {
      return self()->mNumeration;
    }

    /**
      Is Selects the default numeration (IUPAC) Immutable
    */
    static
    bool isNumerationImmutable()
    {
      return self()->isImmutable( QStringLiteral( "numeration" ) );
    }

    /**
      Get Selects the default numeration (IUPAC) default value
    */
    static
    int defaultNumerationValue()
    {
        return defaultNumerationValue_helper();
    }

    /**
      Set Show or hide the legend
    */
    static
    void setShowlegend( bool v )
    {
      if (!self()->isShowlegendImmutable())
        self()->mShowlegend = v;
    }

    /**
      Get Show or hide the legend
    */
    static
    bool showlegend()
    {
      return self()->mShowlegend;
    }

    /**
      Is Show or hide the legend Immutable
    */
    static
    bool isShowlegendImmutable()
    {
      return self()->isImmutable( QStringLiteral( "showlegend" ) );
    }

    /**
      Get Show or hide the legend default value
    */
    static
    bool defaultShowlegendValue()
    {
        return defaultShowlegendValue_helper();
    }

    /**
      Set Whether the atomic mass will be displayed in the PSE-Table
    */
    static
    void setPselook( int v )
    {
      if (!self()->isPselookImmutable())
        self()->mPselook = v;
    }

    /**
      Get Whether the atomic mass will be displayed in the PSE-Table
    */
    static
    int pselook()
    {
      return self()->mPselook;
    }

    /**
      Is Whether the atomic mass will be displayed in the PSE-Table Immutable
    */
    static
    bool isPselookImmutable()
    {
      return self()->isImmutable( QStringLiteral( "pselook" ) );
    }

    /**
      Get Whether the atomic mass will be displayed in the PSE-Table default value
    */
    static
    int defaultPselookValue()
    {
        return defaultPselookValue_helper();
    }

    /**
      Set Selects the table view (default is classical)
    */
    static
    void setTable( int v )
    {
      if (!self()->isTableImmutable())
        self()->mTable = v;
    }

    /**
      Get Selects the table view (default is classical)
    */
    static
    int table()
    {
      return self()->mTable;
    }

    /**
      Is Selects the table view (default is classical) Immutable
    */
    static
    bool isTableImmutable()
    {
      return self()->isImmutable( QStringLiteral( "table" ) );
    }

    /**
      Get Selects the table view (default is classical) default value
    */
    static
    int defaultTableValue()
    {
        return defaultTableValue_helper();
    }

    /**
      Set Whether to use a logarithmic gradient for the Kalzium Covalent Radius Gradient feature
    */
    static
    void setLogarithmicCovalentRadiusGradient( bool v )
    {
      if (!self()->isLogarithmicCovalentRadiusGradientImmutable())
        self()->mLogarithmicCovalentRadiusGradient = v;
    }

    /**
      Get Whether to use a logarithmic gradient for the Kalzium Covalent Radius Gradient feature
    */
    static
    bool logarithmicCovalentRadiusGradient()
    {
      return self()->mLogarithmicCovalentRadiusGradient;
    }

    /**
      Is Whether to use a logarithmic gradient for the Kalzium Covalent Radius Gradient feature Immutable
    */
    static
    bool isLogarithmicCovalentRadiusGradientImmutable()
    {
      return self()->isImmutable( QStringLiteral( "LogarithmicCovalentRadiusGradient" ) );
    }

    /**
      Get Whether to use a logarithmic gradient for the Kalzium Covalent Radius Gradient feature default value
    */
    static
    bool defaultLogarithmicCovalentRadiusGradientValue()
    {
        return defaultLogarithmicCovalentRadiusGradientValue_helper();
    }

    /**
      Set Whether to use a logarithmic gradient for the Kalzium van der Waals Radius Gradient feature
    */
    static
    void setLogarithmicVanDerWaalsRadiusGradient( bool v )
    {
      if (!self()->isLogarithmicVanDerWaalsRadiusGradientImmutable())
        self()->mLogarithmicVanDerWaalsRadiusGradient = v;
    }

    /**
      Get Whether to use a logarithmic gradient for the Kalzium van der Waals Radius Gradient feature
    */
    static
    bool logarithmicVanDerWaalsRadiusGradient()
    {
      return self()->mLogarithmicVanDerWaalsRadiusGradient;
    }

    /**
      Is Whether to use a logarithmic gradient for the Kalzium van der Waals Radius Gradient feature Immutable
    */
    static
    bool isLogarithmicVanDerWaalsRadiusGradientImmutable()
    {
      return self()->isImmutable( QStringLiteral( "LogarithmicVanDerWaalsRadiusGradient" ) );
    }

    /**
      Get Whether to use a logarithmic gradient for the Kalzium van der Waals Radius Gradient feature default value
    */
    static
    bool defaultLogarithmicVanDerWaalsRadiusGradientValue()
    {
        return defaultLogarithmicVanDerWaalsRadiusGradientValue_helper();
    }

    /**
      Set Whether to use a logarithmic gradient for the Kalzium Mass Gradient feature
    */
    static
    void setLogarithmicMassGradient( bool v )
    {
      if (!self()->isLogarithmicMassGradientImmutable())
        self()->mLogarithmicMassGradient = v;
    }

    /**
      Get Whether to use a logarithmic gradient for the Kalzium Mass Gradient feature
    */
    static
    bool logarithmicMassGradient()
    {
      return self()->mLogarithmicMassGradient;
    }

    /**
      Is Whether to use a logarithmic gradient for the Kalzium Mass Gradient feature Immutable
    */
    static
    bool isLogarithmicMassGradientImmutable()
    {
      return self()->isImmutable( QStringLiteral( "LogarithmicMassGradient" ) );
    }

    /**
      Get Whether to use a logarithmic gradient for the Kalzium Mass Gradient feature default value
    */
    static
    bool defaultLogarithmicMassGradientValue()
    {
        return defaultLogarithmicMassGradientValue_helper();
    }

    /**
      Set Whether to use a logarithmic gradient for the Kalzium Boiling Point Gradient feature
    */
    static
    void setLogarithmicBoilingPointGradient( bool v )
    {
      if (!self()->isLogarithmicBoilingPointGradientImmutable())
        self()->mLogarithmicBoilingPointGradient = v;
    }

    /**
      Get Whether to use a logarithmic gradient for the Kalzium Boiling Point Gradient feature
    */
    static
    bool logarithmicBoilingPointGradient()
    {
      return self()->mLogarithmicBoilingPointGradient;
    }

    /**
      Is Whether to use a logarithmic gradient for the Kalzium Boiling Point Gradient feature Immutable
    */
    static
    bool isLogarithmicBoilingPointGradientImmutable()
    {
      return self()->isImmutable( QStringLiteral( "LogarithmicBoilingPointGradient" ) );
    }

    /**
      Get Whether to use a logarithmic gradient for the Kalzium Boiling Point Gradient feature default value
    */
    static
    bool defaultLogarithmicBoilingPointGradientValue()
    {
        return defaultLogarithmicBoilingPointGradientValue_helper();
    }

    /**
      Set Whether to use a logarithmic gradient for the Kalzium Melting Point Gradient feature
    */
    static
    void setLogarithmicMeltingPointGradient( bool v )
    {
      if (!self()->isLogarithmicMeltingPointGradientImmutable())
        self()->mLogarithmicMeltingPointGradient = v;
    }

    /**
      Get Whether to use a logarithmic gradient for the Kalzium Melting Point Gradient feature
    */
    static
    bool logarithmicMeltingPointGradient()
    {
      return self()->mLogarithmicMeltingPointGradient;
    }

    /**
      Is Whether to use a logarithmic gradient for the Kalzium Melting Point Gradient feature Immutable
    */
    static
    bool isLogarithmicMeltingPointGradientImmutable()
    {
      return self()->isImmutable( QStringLiteral( "LogarithmicMeltingPointGradient" ) );
    }

    /**
      Get Whether to use a logarithmic gradient for the Kalzium Melting Point Gradient feature default value
    */
    static
    bool defaultLogarithmicMeltingPointGradientValue()
    {
        return defaultLogarithmicMeltingPointGradientValue_helper();
    }

    /**
      Set Whether to use a logarithmic gradient for the Kalzium Electronegativity Gradient feature
    */
    static
    void setLogarithmicElectronegativityGradient( bool v )
    {
      if (!self()->isLogarithmicElectronegativityGradientImmutable())
        self()->mLogarithmicElectronegativityGradient = v;
    }

    /**
      Get Whether to use a logarithmic gradient for the Kalzium Electronegativity Gradient feature
    */
    static
    bool logarithmicElectronegativityGradient()
    {
      return self()->mLogarithmicElectronegativityGradient;
    }

    /**
      Is Whether to use a logarithmic gradient for the Kalzium Electronegativity Gradient feature Immutable
    */
    static
    bool isLogarithmicElectronegativityGradientImmutable()
    {
      return self()->isImmutable( QStringLiteral( "LogarithmicElectronegativityGradient" ) );
    }

    /**
      Get Whether to use a logarithmic gradient for the Kalzium Electronegativity Gradient feature default value
    */
    static
    bool defaultLogarithmicElectronegativityGradientValue()
    {
        return defaultLogarithmicElectronegativityGradientValue_helper();
    }

    /**
      Set Whether to use a logarithmic gradient for the Kalzium Discovery Date Gradient feature
    */
    static
    void setLogarithmicDiscoverydateGradient( bool v )
    {
      if (!self()->isLogarithmicDiscoverydateGradientImmutable())
        self()->mLogarithmicDiscoverydateGradient = v;
    }

    /**
      Get Whether to use a logarithmic gradient for the Kalzium Discovery Date Gradient feature
    */
    static
    bool logarithmicDiscoverydateGradient()
    {
      return self()->mLogarithmicDiscoverydateGradient;
    }

    /**
      Is Whether to use a logarithmic gradient for the Kalzium Discovery Date Gradient feature Immutable
    */
    static
    bool isLogarithmicDiscoverydateGradientImmutable()
    {
      return self()->isImmutable( QStringLiteral( "LogarithmicDiscoverydateGradient" ) );
    }

    /**
      Get Whether to use a logarithmic gradient for the Kalzium Discovery Date Gradient feature default value
    */
    static
    bool defaultLogarithmicDiscoverydateGradientValue()
    {
        return defaultLogarithmicDiscoverydateGradientValue_helper();
    }

    /**
      Set Whether to use a logarithmic gradient for the Kalzium Electron Affinity Gradient feature
    */
    static
    void setLogarithmicElectronaffinityGradient( bool v )
    {
      if (!self()->isLogarithmicElectronaffinityGradientImmutable())
        self()->mLogarithmicElectronaffinityGradient = v;
    }

    /**
      Get Whether to use a logarithmic gradient for the Kalzium Electron Affinity Gradient feature
    */
    static
    bool logarithmicElectronaffinityGradient()
    {
      return self()->mLogarithmicElectronaffinityGradient;
    }

    /**
      Is Whether to use a logarithmic gradient for the Kalzium Electron Affinity Gradient feature Immutable
    */
    static
    bool isLogarithmicElectronaffinityGradientImmutable()
    {
      return self()->isImmutable( QStringLiteral( "LogarithmicElectronaffinityGradient" ) );
    }

    /**
      Get Whether to use a logarithmic gradient for the Kalzium Electron Affinity Gradient feature default value
    */
    static
    bool defaultLogarithmicElectronaffinityGradientValue()
    {
        return defaultLogarithmicElectronaffinityGradientValue_helper();
    }

    /**
      Set Whether to use a logarithmic gradient for the Kalzium Ionization Gradient feature
    */
    static
    void setLogarithmicIonizationGradient( bool v )
    {
      if (!self()->isLogarithmicIonizationGradientImmutable())
        self()->mLogarithmicIonizationGradient = v;
    }

    /**
      Get Whether to use a logarithmic gradient for the Kalzium Ionization Gradient feature
    */
    static
    bool logarithmicIonizationGradient()
    {
      return self()->mLogarithmicIonizationGradient;
    }

    /**
      Is Whether to use a logarithmic gradient for the Kalzium Ionization Gradient feature Immutable
    */
    static
    bool isLogarithmicIonizationGradientImmutable()
    {
      return self()->isImmutable( QStringLiteral( "LogarithmicIonizationGradient" ) );
    }

    /**
      Get Whether to use a logarithmic gradient for the Kalzium Ionization Gradient feature default value
    */
    static
    bool defaultLogarithmicIonizationGradientValue()
    {
        return defaultLogarithmicIonizationGradientValue_helper();
    }

    /**
      Set Selects the default gradient color
    */
    static
    void setColorgradientbox( int v )
    {
      if (!self()->isColorgradientboxImmutable())
        self()->mColorgradientbox = v;
    }

    /**
      Get Selects the default gradient color
    */
    static
    int colorgradientbox()
    {
      return self()->mColorgradientbox;
    }

    /**
      Is Selects the default gradient color Immutable
    */
    static
    bool isColorgradientboxImmutable()
    {
      return self()->isImmutable( QStringLiteral( "colorgradientbox" ) );
    }

    /**
      Get Selects the default gradient color default value
    */
    static
    int defaultColorgradientboxValue()
    {
        return defaultColorgradientboxValue_helper();
    }

    /**
      Set Selects the color if no scheme is selected
    */
    static
    void setNoscheme( const QColor & v )
    {
      if (!self()->isNoschemeImmutable())
        self()->mNoscheme = v;
    }

    /**
      Get Selects the color if no scheme is selected
    */
    static
    QColor noscheme()
    {
      return self()->mNoscheme;
    }

    /**
      Is Selects the color if no scheme is selected Immutable
    */
    static
    bool isNoschemeImmutable()
    {
      return self()->isImmutable( QStringLiteral( "noscheme" ) );
    }

    /**
      Get Selects the color if no scheme is selected default value
    */
    static
    QColor defaultNoschemeValue()
    {
        return defaultNoschemeValue_helper();
    }

    /**
      Set Selects the color of liquid elements
    */
    static
    void setColor_liquid( const QColor & v )
    {
      if (!self()->isColor_liquidImmutable())
        self()->mColor_liquid = v;
    }

    /**
      Get Selects the color of liquid elements
    */
    static
    QColor color_liquid()
    {
      return self()->mColor_liquid;
    }

    /**
      Is Selects the color of liquid elements Immutable
    */
    static
    bool isColor_liquidImmutable()
    {
      return self()->isImmutable( QStringLiteral( "color_liquid" ) );
    }

    /**
      Get Selects the color of liquid elements default value
    */
    static
    QColor defaultColor_liquidValue()
    {
        return defaultColor_liquidValue_helper();
    }

    /**
      Set Selects the color of solid elements
    */
    static
    void setColor_solid( const QColor & v )
    {
      if (!self()->isColor_solidImmutable())
        self()->mColor_solid = v;
    }

    /**
      Get Selects the color of solid elements
    */
    static
    QColor color_solid()
    {
      return self()->mColor_solid;
    }

    /**
      Is Selects the color of solid elements Immutable
    */
    static
    bool isColor_solidImmutable()
    {
      return self()->isImmutable( QStringLiteral( "color_solid" ) );
    }

    /**
      Get Selects the color of solid elements default value
    */
    static
    QColor defaultColor_solidValue()
    {
        return defaultColor_solidValue_helper();
    }

    /**
      Set Selects the color of vaporous elements
    */
    static
    void setColor_vapor( const QColor & v )
    {
      if (!self()->isColor_vaporImmutable())
        self()->mColor_vapor = v;
    }

    /**
      Get Selects the color of vaporous elements
    */
    static
    QColor color_vapor()
    {
      return self()->mColor_vapor;
    }

    /**
      Is Selects the color of vaporous elements Immutable
    */
    static
    bool isColor_vaporImmutable()
    {
      return self()->isImmutable( QStringLiteral( "color_vapor" ) );
    }

    /**
      Get Selects the color of vaporous elements default value
    */
    static
    QColor defaultColor_vaporValue()
    {
        return defaultColor_vaporValue_helper();
    }

    /**
      Set Selects the color of radioactive elements
    */
    static
    void setColor_radioactive( const QColor & v )
    {
      if (!self()->isColor_radioactiveImmutable())
        self()->mColor_radioactive = v;
    }

    /**
      Get Selects the color of radioactive elements
    */
    static
    QColor color_radioactive()
    {
      return self()->mColor_radioactive;
    }

    /**
      Is Selects the color of radioactive elements Immutable
    */
    static
    bool isColor_radioactiveImmutable()
    {
      return self()->isImmutable( QStringLiteral( "color_radioactive" ) );
    }

    /**
      Get Selects the color of radioactive elements default value
    */
    static
    QColor defaultColor_radioactiveValue()
    {
        return defaultColor_radioactiveValue_helper();
    }

    /**
      Set Selects the color of artificial elements
    */
    static
    void setColor_artificial( const QColor & v )
    {
      if (!self()->isColor_artificialImmutable())
        self()->mColor_artificial = v;
    }

    /**
      Get Selects the color of artificial elements
    */
    static
    QColor color_artificial()
    {
      return self()->mColor_artificial;
    }

    /**
      Is Selects the color of artificial elements Immutable
    */
    static
    bool isColor_artificialImmutable()
    {
      return self()->isImmutable( QStringLiteral( "color_artificial" ) );
    }

    /**
      Get Selects the color of artificial elements default value
    */
    static
    QColor defaultColor_artificialValue()
    {
        return defaultColor_artificialValue_helper();
    }

    /**
      Set Selects the color of the elements in block s
    */
    static
    void setBlock_s( const QColor & v )
    {
      if (!self()->isBlock_sImmutable())
        self()->mBlock_s = v;
    }

    /**
      Get Selects the color of the elements in block s
    */
    static
    QColor block_s()
    {
      return self()->mBlock_s;
    }

    /**
      Is Selects the color of the elements in block s Immutable
    */
    static
    bool isBlock_sImmutable()
    {
      return self()->isImmutable( QStringLiteral( "block_s" ) );
    }

    /**
      Get Selects the color of the elements in block s default value
    */
    static
    QColor defaultBlock_sValue()
    {
        return defaultBlock_sValue_helper();
    }

    /**
      Set Selects the color of the elements in block p
    */
    static
    void setBlock_p( const QColor & v )
    {
      if (!self()->isBlock_pImmutable())
        self()->mBlock_p = v;
    }

    /**
      Get Selects the color of the elements in block p
    */
    static
    QColor block_p()
    {
      return self()->mBlock_p;
    }

    /**
      Is Selects the color of the elements in block p Immutable
    */
    static
    bool isBlock_pImmutable()
    {
      return self()->isImmutable( QStringLiteral( "block_p" ) );
    }

    /**
      Get Selects the color of the elements in block p default value
    */
    static
    QColor defaultBlock_pValue()
    {
        return defaultBlock_pValue_helper();
    }

    /**
      Set Selects the color of the elements in block d
    */
    static
    void setBlock_d( const QColor & v )
    {
      if (!self()->isBlock_dImmutable())
        self()->mBlock_d = v;
    }

    /**
      Get Selects the color of the elements in block d
    */
    static
    QColor block_d()
    {
      return self()->mBlock_d;
    }

    /**
      Is Selects the color of the elements in block d Immutable
    */
    static
    bool isBlock_dImmutable()
    {
      return self()->isImmutable( QStringLiteral( "block_d" ) );
    }

    /**
      Get Selects the color of the elements in block d default value
    */
    static
    QColor defaultBlock_dValue()
    {
        return defaultBlock_dValue_helper();
    }

    /**
      Set Selects the color of the elements in block f
    */
    static
    void setBlock_f( const QColor & v )
    {
      if (!self()->isBlock_fImmutable())
        self()->mBlock_f = v;
    }

    /**
      Get Selects the color of the elements in block f
    */
    static
    QColor block_f()
    {
      return self()->mBlock_f;
    }

    /**
      Is Selects the color of the elements in block f Immutable
    */
    static
    bool isBlock_fImmutable()
    {
      return self()->isImmutable( QStringLiteral( "block_f" ) );
    }

    /**
      Get Selects the color of the elements in block f default value
    */
    static
    QColor defaultBlock_fValue()
    {
        return defaultBlock_fValue_helper();
    }

    /**
      Set Selects the color of the elements in group 1
    */
    static
    void setGroup_1( const QColor & v )
    {
      if (!self()->isGroup_1Immutable())
        self()->mGroup_1 = v;
    }

    /**
      Get Selects the color of the elements in group 1
    */
    static
    QColor group_1()
    {
      return self()->mGroup_1;
    }

    /**
      Is Selects the color of the elements in group 1 Immutable
    */
    static
    bool isGroup_1Immutable()
    {
      return self()->isImmutable( QStringLiteral( "group_1" ) );
    }

    /**
      Get Selects the color of the elements in group 1 default value
    */
    static
    QColor defaultGroup_1Value()
    {
        return defaultGroup_1Value_helper();
    }

    /**
      Set Selects the color of the elements in group 2
    */
    static
    void setGroup_2( const QColor & v )
    {
      if (!self()->isGroup_2Immutable())
        self()->mGroup_2 = v;
    }

    /**
      Get Selects the color of the elements in group 2
    */
    static
    QColor group_2()
    {
      return self()->mGroup_2;
    }

    /**
      Is Selects the color of the elements in group 2 Immutable
    */
    static
    bool isGroup_2Immutable()
    {
      return self()->isImmutable( QStringLiteral( "group_2" ) );
    }

    /**
      Get Selects the color of the elements in group 2 default value
    */
    static
    QColor defaultGroup_2Value()
    {
        return defaultGroup_2Value_helper();
    }

    /**
      Set Selects the color of the elements in group 3
    */
    static
    void setGroup_3( const QColor & v )
    {
      if (!self()->isGroup_3Immutable())
        self()->mGroup_3 = v;
    }

    /**
      Get Selects the color of the elements in group 3
    */
    static
    QColor group_3()
    {
      return self()->mGroup_3;
    }

    /**
      Is Selects the color of the elements in group 3 Immutable
    */
    static
    bool isGroup_3Immutable()
    {
      return self()->isImmutable( QStringLiteral( "group_3" ) );
    }

    /**
      Get Selects the color of the elements in group 3 default value
    */
    static
    QColor defaultGroup_3Value()
    {
        return defaultGroup_3Value_helper();
    }

    /**
      Set Selects the color of the elements in group 4
    */
    static
    void setGroup_4( const QColor & v )
    {
      if (!self()->isGroup_4Immutable())
        self()->mGroup_4 = v;
    }

    /**
      Get Selects the color of the elements in group 4
    */
    static
    QColor group_4()
    {
      return self()->mGroup_4;
    }

    /**
      Is Selects the color of the elements in group 4 Immutable
    */
    static
    bool isGroup_4Immutable()
    {
      return self()->isImmutable( QStringLiteral( "group_4" ) );
    }

    /**
      Get Selects the color of the elements in group 4 default value
    */
    static
    QColor defaultGroup_4Value()
    {
        return defaultGroup_4Value_helper();
    }

    /**
      Set Selects the color of the elements in group 5
    */
    static
    void setGroup_5( const QColor & v )
    {
      if (!self()->isGroup_5Immutable())
        self()->mGroup_5 = v;
    }

    /**
      Get Selects the color of the elements in group 5
    */
    static
    QColor group_5()
    {
      return self()->mGroup_5;
    }

    /**
      Is Selects the color of the elements in group 5 Immutable
    */
    static
    bool isGroup_5Immutable()
    {
      return self()->isImmutable( QStringLiteral( "group_5" ) );
    }

    /**
      Get Selects the color of the elements in group 5 default value
    */
    static
    QColor defaultGroup_5Value()
    {
        return defaultGroup_5Value_helper();
    }

    /**
      Set Selects the color of the elements in group 6
    */
    static
    void setGroup_6( const QColor & v )
    {
      if (!self()->isGroup_6Immutable())
        self()->mGroup_6 = v;
    }

    /**
      Get Selects the color of the elements in group 6
    */
    static
    QColor group_6()
    {
      return self()->mGroup_6;
    }

    /**
      Is Selects the color of the elements in group 6 Immutable
    */
    static
    bool isGroup_6Immutable()
    {
      return self()->isImmutable( QStringLiteral( "group_6" ) );
    }

    /**
      Get Selects the color of the elements in group 6 default value
    */
    static
    QColor defaultGroup_6Value()
    {
        return defaultGroup_6Value_helper();
    }

    /**
      Set Selects the color of the elements in group 7
    */
    static
    void setGroup_7( const QColor & v )
    {
      if (!self()->isGroup_7Immutable())
        self()->mGroup_7 = v;
    }

    /**
      Get Selects the color of the elements in group 7
    */
    static
    QColor group_7()
    {
      return self()->mGroup_7;
    }

    /**
      Is Selects the color of the elements in group 7 Immutable
    */
    static
    bool isGroup_7Immutable()
    {
      return self()->isImmutable( QStringLiteral( "group_7" ) );
    }

    /**
      Get Selects the color of the elements in group 7 default value
    */
    static
    QColor defaultGroup_7Value()
    {
        return defaultGroup_7Value_helper();
    }

    /**
      Set Selects the color of the elements in group 8
    */
    static
    void setGroup_8( const QColor & v )
    {
      if (!self()->isGroup_8Immutable())
        self()->mGroup_8 = v;
    }

    /**
      Get Selects the color of the elements in group 8
    */
    static
    QColor group_8()
    {
      return self()->mGroup_8;
    }

    /**
      Is Selects the color of the elements in group 8 Immutable
    */
    static
    bool isGroup_8Immutable()
    {
      return self()->isImmutable( QStringLiteral( "group_8" ) );
    }

    /**
      Get Selects the color of the elements in group 8 default value
    */
    static
    QColor defaultGroup_8Value()
    {
        return defaultGroup_8Value_helper();
    }

    /**
      Set Selects the color of the alkali metals
    */
    static
    void setAlkali_metal( const QColor & v )
    {
      if (!self()->isAlkali_metalImmutable())
        self()->mAlkali_metal = v;
    }

    /**
      Get Selects the color of the alkali metals
    */
    static
    QColor alkali_metal()
    {
      return self()->mAlkali_metal;
    }

    /**
      Is Selects the color of the alkali metals Immutable
    */
    static
    bool isAlkali_metalImmutable()
    {
      return self()->isImmutable( QStringLiteral( "alkali_metal" ) );
    }

    /**
      Get Selects the color of the alkali metals default value
    */
    static
    QColor defaultAlkali_metalValue()
    {
        return defaultAlkali_metalValue_helper();
    }

    /**
      Set Selects the color of the rare-earth elements
    */
    static
    void setRare( const QColor & v )
    {
      if (!self()->isRareImmutable())
        self()->mRare = v;
    }

    /**
      Get Selects the color of the rare-earth elements
    */
    static
    QColor rare()
    {
      return self()->mRare;
    }

    /**
      Is Selects the color of the rare-earth elements Immutable
    */
    static
    bool isRareImmutable()
    {
      return self()->isImmutable( QStringLiteral( "rare" ) );
    }

    /**
      Get Selects the color of the rare-earth elements default value
    */
    static
    QColor defaultRareValue()
    {
        return defaultRareValue_helper();
    }

    /**
      Set Selects the color of the non-metal elements
    */
    static
    void setNonmetal( const QColor & v )
    {
      if (!self()->isNonmetalImmutable())
        self()->mNonmetal = v;
    }

    /**
      Get Selects the color of the non-metal elements
    */
    static
    QColor nonmetal()
    {
      return self()->mNonmetal;
    }

    /**
      Is Selects the color of the non-metal elements Immutable
    */
    static
    bool isNonmetalImmutable()
    {
      return self()->isImmutable( QStringLiteral( "nonmetal" ) );
    }

    /**
      Get Selects the color of the non-metal elements default value
    */
    static
    QColor defaultNonmetalValue()
    {
        return defaultNonmetalValue_helper();
    }

    /**
      Set Selects the color of the alkaline earth metals
    */
    static
    void setAlkaline_earth_metal( const QColor & v )
    {
      if (!self()->isAlkaline_earth_metalImmutable())
        self()->mAlkaline_earth_metal = v;
    }

    /**
      Get Selects the color of the alkaline earth metals
    */
    static
    QColor alkaline_earth_metal()
    {
      return self()->mAlkaline_earth_metal;
    }

    /**
      Is Selects the color of the alkaline earth metals Immutable
    */
    static
    bool isAlkaline_earth_metalImmutable()
    {
      return self()->isImmutable( QStringLiteral( "alkaline_earth_metal" ) );
    }

    /**
      Get Selects the color of the alkaline earth metals default value
    */
    static
    QColor defaultAlkaline_earth_metalValue()
    {
        return defaultAlkaline_earth_metalValue_helper();
    }

    /**
      Set Selects the color of the metals which do not fit into the other categories
    */
    static
    void setOther_metal( const QColor & v )
    {
      if (!self()->isOther_metalImmutable())
        self()->mOther_metal = v;
    }

    /**
      Get Selects the color of the metals which do not fit into the other categories
    */
    static
    QColor other_metal()
    {
      return self()->mOther_metal;
    }

    /**
      Is Selects the color of the metals which do not fit into the other categories Immutable
    */
    static
    bool isOther_metalImmutable()
    {
      return self()->isImmutable( QStringLiteral( "other_metal" ) );
    }

    /**
      Get Selects the color of the metals which do not fit into the other categories default value
    */
    static
    QColor defaultOther_metalValue()
    {
        return defaultOther_metalValue_helper();
    }

    /**
      Set Selects the color of the halogen elements
    */
    static
    void setHalogene( const QColor & v )
    {
      if (!self()->isHalogeneImmutable())
        self()->mHalogene = v;
    }

    /**
      Get Selects the color of the halogen elements
    */
    static
    QColor halogene()
    {
      return self()->mHalogene;
    }

    /**
      Is Selects the color of the halogen elements Immutable
    */
    static
    bool isHalogeneImmutable()
    {
      return self()->isImmutable( QStringLiteral( "halogene" ) );
    }

    /**
      Get Selects the color of the halogen elements default value
    */
    static
    QColor defaultHalogeneValue()
    {
        return defaultHalogeneValue_helper();
    }

    /**
      Set Selects the color of the transition elements
    */
    static
    void setTransition( const QColor & v )
    {
      if (!self()->isTransitionImmutable())
        self()->mTransition = v;
    }

    /**
      Get Selects the color of the transition elements
    */
    static
    QColor transition()
    {
      return self()->mTransition;
    }

    /**
      Is Selects the color of the transition elements Immutable
    */
    static
    bool isTransitionImmutable()
    {
      return self()->isImmutable( QStringLiteral( "transition" ) );
    }

    /**
      Get Selects the color of the transition elements default value
    */
    static
    QColor defaultTransitionValue()
    {
        return defaultTransitionValue_helper();
    }

    /**
      Set Selects the color of the noble gases
    */
    static
    void setNoble_gas( const QColor & v )
    {
      if (!self()->isNoble_gasImmutable())
        self()->mNoble_gas = v;
    }

    /**
      Get Selects the color of the noble gases
    */
    static
    QColor noble_gas()
    {
      return self()->mNoble_gas;
    }

    /**
      Is Selects the color of the noble gases Immutable
    */
    static
    bool isNoble_gasImmutable()
    {
      return self()->isImmutable( QStringLiteral( "noble_gas" ) );
    }

    /**
      Get Selects the color of the noble gases default value
    */
    static
    QColor defaultNoble_gasValue()
    {
        return defaultNoble_gasValue_helper();
    }

    /**
      Set Selects the color of the metalloid elements
    */
    static
    void setMetalloid( const QColor & v )
    {
      if (!self()->isMetalloidImmutable())
        self()->mMetalloid = v;
    }

    /**
      Get Selects the color of the metalloid elements
    */
    static
    QColor metalloid()
    {
      return self()->mMetalloid;
    }

    /**
      Is Selects the color of the metalloid elements Immutable
    */
    static
    bool isMetalloidImmutable()
    {
      return self()->isImmutable( QStringLiteral( "metalloid" ) );
    }

    /**
      Get Selects the color of the metalloid elements default value
    */
    static
    QColor defaultMetalloidValue()
    {
        return defaultMetalloidValue_helper();
    }

    /**
      Set Selects the color of the maximal value from the gradient
    */
    static
    void setMaxColor( const QColor & v )
    {
      if (!self()->isMaxColorImmutable())
        self()->mMaxColor = v;
    }

    /**
      Get Selects the color of the maximal value from the gradient
    */
    static
    QColor maxColor()
    {
      return self()->mMaxColor;
    }

    /**
      Is Selects the color of the maximal value from the gradient Immutable
    */
    static
    bool isMaxColorImmutable()
    {
      return self()->isImmutable( QStringLiteral( "MaxColor" ) );
    }

    /**
      Get Selects the color of the maximal value from the gradient default value
    */
    static
    QColor defaultMaxColorValue()
    {
        return defaultMaxColorValue_helper();
    }

    /**
      Set Selects the color of the minimal value from the gradient
    */
    static
    void setMinColor( const QColor & v )
    {
      if (!self()->isMinColorImmutable())
        self()->mMinColor = v;
    }

    /**
      Get Selects the color of the minimal value from the gradient
    */
    static
    QColor minColor()
    {
      return self()->mMinColor;
    }

    /**
      Is Selects the color of the minimal value from the gradient Immutable
    */
    static
    bool isMinColorImmutable()
    {
      return self()->isImmutable( QStringLiteral( "MinColor" ) );
    }

    /**
      Get Selects the color of the minimal value from the gradient default value
    */
    static
    QColor defaultMinColorValue()
    {
        return defaultMinColorValue_helper();
    }

    /**
      Set This value defines whether eV or kJ/mol should be used within Kalzium
    */
    static
    void setEnergiesUnit( int v )
    {
      if (!self()->isEnergiesUnitImmutable())
        self()->mEnergiesUnit = v;
    }

    /**
      Get This value defines whether eV or kJ/mol should be used within Kalzium
    */
    static
    int energiesUnit()
    {
      return self()->mEnergiesUnit;
    }

    /**
      Is This value defines whether eV or kJ/mol should be used within Kalzium Immutable
    */
    static
    bool isEnergiesUnitImmutable()
    {
      return self()->isImmutable( QStringLiteral( "energiesUnit" ) );
    }

    /**
      Get This value defines whether eV or kJ/mol should be used within Kalzium default value
    */
    static
    int defaultEnergiesUnitValue()
    {
        return defaultEnergiesUnitValue_helper();
    }

    /**
      Set This value defines which temperature scale should be used within Kalzium
    */
    static
    void setTemperatureUnit( int v )
    {
      if (!self()->isTemperatureUnitImmutable())
        self()->mTemperatureUnit = v;
    }

    /**
      Get This value defines which temperature scale should be used within Kalzium
    */
    static
    int temperatureUnit()
    {
      return self()->mTemperatureUnit;
    }

    /**
      Is This value defines which temperature scale should be used within Kalzium Immutable
    */
    static
    bool isTemperatureUnitImmutable()
    {
      return self()->isImmutable( QStringLiteral( "temperatureUnit" ) );
    }

    /**
      Get This value defines which temperature scale should be used within Kalzium default value
    */
    static
    int defaultTemperatureUnitValue()
    {
        return defaultTemperatureUnitValue_helper();
    }

    /**
      Set This value defines which length scale should be used within Kalzium
    */
    static
    void setLengthUnit( int v )
    {
      if (!self()->isLengthUnitImmutable())
        self()->mLengthUnit = v;
    }

    /**
      Get This value defines which length scale should be used within Kalzium
    */
    static
    int lengthUnit()
    {
      return self()->mLengthUnit;
    }

    /**
      Is This value defines which length scale should be used within Kalzium Immutable
    */
    static
    bool isLengthUnitImmutable()
    {
      return self()->isImmutable( QStringLiteral( "lengthUnit" ) );
    }

    /**
      Get This value defines which length scale should be used within Kalzium default value
    */
    static
    int defaultLengthUnitValue()
    {
        return defaultLengthUnitValue_helper();
    }

    /**
      Set This value defines whether eV or kJ/mol should be used within Kalzium
    */
    static
    void setCombobox_energies( int v )
    {
      if (!self()->isCombobox_energiesImmutable())
        self()->mCombobox_energies = v;
    }

    /**
      Get This value defines whether eV or kJ/mol should be used within Kalzium
    */
    static
    int combobox_energies()
    {
      return self()->mCombobox_energies;
    }

    /**
      Is This value defines whether eV or kJ/mol should be used within Kalzium Immutable
    */
    static
    bool isCombobox_energiesImmutable()
    {
      return self()->isImmutable( QStringLiteral( "combobox_energies" ) );
    }

    /**
      Get This value defines whether eV or kJ/mol should be used within Kalzium default value
    */
    static
    int defaultCombobox_energiesValue()
    {
        return defaultCombobox_energiesValue_helper();
    }

    /**
      Set This value defines which temperature scale should be used within Kalzium
    */
    static
    void setCombobox_temperature( int v )
    {
      if (!self()->isCombobox_temperatureImmutable())
        self()->mCombobox_temperature = v;
    }

    /**
      Get This value defines which temperature scale should be used within Kalzium
    */
    static
    int combobox_temperature()
    {
      return self()->mCombobox_temperature;
    }

    /**
      Is This value defines which temperature scale should be used within Kalzium Immutable
    */
    static
    bool isCombobox_temperatureImmutable()
    {
      return self()->isImmutable( QStringLiteral( "combobox_temperature" ) );
    }

    /**
      Get This value defines which temperature scale should be used within Kalzium default value
    */
    static
    int defaultCombobox_temperatureValue()
    {
        return defaultCombobox_temperatureValue_helper();
    }

    /**
      Set This value defines which length scale should be used within Kalzium
    */
    static
    void setCombobox_length( int v )
    {
      if (!self()->isCombobox_lengthImmutable())
        self()->mCombobox_length = v;
    }

    /**
      Get This value defines which length scale should be used within Kalzium
    */
    static
    int combobox_length()
    {
      return self()->mCombobox_length;
    }

    /**
      Is This value defines which length scale should be used within Kalzium Immutable
    */
    static
    bool isCombobox_lengthImmutable()
    {
      return self()->isImmutable( QStringLiteral( "combobox_length" ) );
    }

    /**
      Get This value defines which length scale should be used within Kalzium default value
    */
    static
    int defaultCombobox_lengthValue()
    {
        return defaultCombobox_lengthValue_helper();
    }

    /**
      Set True if schema was last selected
    */
    static
    void setSchemaSelected( bool v )
    {
      if (!self()->isSchemaSelectedImmutable())
        self()->mSchemaSelected = v;
    }

    /**
      Get True if schema was last selected
    */
    static
    bool schemaSelected()
    {
      return self()->mSchemaSelected;
    }

    /**
      Is True if schema was last selected Immutable
    */
    static
    bool isSchemaSelectedImmutable()
    {
      return self()->isImmutable( QStringLiteral( "schemaSelected" ) );
    }

    /**
      Get True if schema was last selected default value
    */
    static
    bool defaultSchemaSelectedValue()
    {
        return defaultSchemaSelectedValue_helper();
    }

    /**
      Set This value defines which unit is used for the wavelength
    */
    static
    void setSpectrumWavelengthUnit( int v )
    {
      if (!self()->isSpectrumWavelengthUnitImmutable())
        self()->mSpectrumWavelengthUnit = v;
    }

    /**
      Get This value defines which unit is used for the wavelength
    */
    static
    int spectrumWavelengthUnit()
    {
      return self()->mSpectrumWavelengthUnit;
    }

    /**
      Is This value defines which unit is used for the wavelength Immutable
    */
    static
    bool isSpectrumWavelengthUnitImmutable()
    {
      return self()->isImmutable( QStringLiteral( "spectrumWavelengthUnit" ) );
    }

    /**
      Get This value defines which unit is used for the wavelength default value
    */
    static
    int defaultSpectrumWavelengthUnitValue()
    {
        return defaultSpectrumWavelengthUnitValue_helper();
    }

    /**
      Set This value defines which Spectrum type is used. Emission or absorption spectrum
    */
    static
    void setSpectrumType( int v )
    {
      if (!self()->isSpectrumTypeImmutable())
        self()->mSpectrumType = v;
    }

    /**
      Get This value defines which Spectrum type is used. Emission or absorption spectrum
    */
    static
    int spectrumType()
    {
      return self()->mSpectrumType;
    }

    /**
      Is This value defines which Spectrum type is used. Emission or absorption spectrum Immutable
    */
    static
    bool isSpectrumTypeImmutable()
    {
      return self()->isImmutable( QStringLiteral( "spectrumType" ) );
    }

    /**
      Get This value defines which Spectrum type is used. Emission or absorption spectrum default value
    */
    static
    int defaultSpectrumTypeValue()
    {
        return defaultSpectrumTypeValue_helper();
    }

    /**
      Set This setting tells the nuclear calculator whether the amounts are always in terms of mass
    */
    static
    void setMass( bool v )
    {
      if (!self()->isMassImmutable())
        self()->mMass = v;
    }

    /**
      Get This setting tells the nuclear calculator whether the amounts are always in terms of mass
    */
    static
    bool mass()
    {
      return self()->mMass;
    }

    /**
      Is This setting tells the nuclear calculator whether the amounts are always in terms of mass Immutable
    */
    static
    bool isMassImmutable()
    {
      return self()->isImmutable( QStringLiteral( "mass" ) );
    }

    /**
      Set This setting says whether the user wants the gas to be ideal by default
    */
    static
    void setIdeal( bool v )
    {
      if (!self()->isIdealImmutable())
        self()->mIdeal = v;
    }

    /**
      Get This setting says whether the user wants the gas to be ideal by default
    */
    static
    bool ideal()
    {
      return self()->mIdeal;
    }

    /**
      Is This setting says whether the user wants the gas to be ideal by default Immutable
    */
    static
    bool isIdealImmutable()
    {
      return self()->isImmutable( QStringLiteral( "ideal" ) );
    }

    /**
      Get This setting says whether the user wants the gas to be ideal by default default value
    */
    static
    bool defaultIdealValue()
    {
        return defaultIdealValue_helper();
    }

    /**
      Set This setting tells the concentration calculator that amount of solute is always in mass
    */
    static
    void setSoluteMass( bool v )
    {
      if (!self()->isSoluteMassImmutable())
        self()->mSoluteMass = v;
    }

    /**
      Get This setting tells the concentration calculator that amount of solute is always in mass
    */
    static
    bool soluteMass()
    {
      return self()->mSoluteMass;
    }

    /**
      Is This setting tells the concentration calculator that amount of solute is always in mass Immutable
    */
    static
    bool isSoluteMassImmutable()
    {
      return self()->isImmutable( QStringLiteral( "soluteMass" ) );
    }

    /**
      Set This setting tells the concentration calculator that amount of solvent is always in volume
    */
    static
    void setSolventVolume( bool v )
    {
      if (!self()->isSolventVolumeImmutable())
        self()->mSolventVolume = v;
    }

    /**
      Get This setting tells the concentration calculator that amount of solvent is always in volume
    */
    static
    bool solventVolume()
    {
      return self()->mSolventVolume;
    }

    /**
      Is This setting tells the concentration calculator that amount of solvent is always in volume Immutable
    */
    static
    bool isSolventVolumeImmutable()
    {
      return self()->isImmutable( QStringLiteral( "solventVolume" ) );
    }

    /**
      Set This setting tells the molecular mass calculator whether extra details such as aliases should be shown
    */
    static
    void setAlias( bool v )
    {
      if (!self()->isAliasImmutable())
        self()->mAlias = v;
    }

    /**
      Get This setting tells the molecular mass calculator whether extra details such as aliases should be shown
    */
    static
    bool alias()
    {
      return self()->mAlias;
    }

    /**
      Is This setting tells the molecular mass calculator whether extra details such as aliases should be shown Immutable
    */
    static
    bool isAliasImmutable()
    {
      return self()->isImmutable( QStringLiteral( "alias" ) );
    }

    /**
      Set This setting tells the molecular calculator whether the add Alias tab should be shown
    */
    static
    void setAddAlias( bool v )
    {
      if (!self()->isAddAliasImmutable())
        self()->mAddAlias = v;
    }

    /**
      Get This setting tells the molecular calculator whether the add Alias tab should be shown
    */
    static
    bool addAlias()
    {
      return self()->mAddAlias;
    }

    /**
      Is This setting tells the molecular calculator whether the add Alias tab should be shown Immutable
    */
    static
    bool isAddAliasImmutable()
    {
      return self()->isImmutable( QStringLiteral( "addAlias" ) );
    }

    /**
      Set Show or hide the sidebar
    */
    static
    void setShowsidebar( bool v )
    {
      if (!self()->isShowsidebarImmutable())
        self()->mShowsidebar = v;
    }

    /**
      Get Show or hide the sidebar
    */
    static
    bool showsidebar()
    {
      return self()->mShowsidebar;
    }

    /**
      Is Show or hide the sidebar Immutable
    */
    static
    bool isShowsidebarImmutable()
    {
      return self()->isImmutable( QStringLiteral( "showsidebar" ) );
    }

    /**
      Get Show or hide the sidebar default value
    */
    static
    bool defaultShowsidebarValue()
    {
        return defaultShowsidebarValue_helper();
    }

    /**
      Set Display-Mode of the Isotope Table
    */
    static
    void setIsotopeTableMode( int v )
    {
      if (v != self()->mIsotopeTableMode && !self()->isIsotopeTableModeImmutable()) {
        self()->mIsotopeTableMode = v;
        self()->mSettingsChanged.insert(signalIsotopeTableModeChanged);
      }
    }

    /**
      Get Display-Mode of the Isotope Table
    */
    static
    int isotopeTableMode()
    {
      return self()->mIsotopeTableMode;
    }

    /**
      Is Display-Mode of the Isotope Table Immutable
    */
    static
    bool isIsotopeTableModeImmutable()
    {
      return self()->isImmutable( QStringLiteral( "isotopeTableMode" ) );
    }

    /**
      Get Display-Mode of the Isotope Table default value
    */
    static
    int defaultIsotopeTableModeValue()
    {
        return defaultIsotopeTableModeValue_helper();
    }


    enum {
      signalIsotopeTableModeChanged = 1
    };

  Q_SIGNALS:
    void isotopeTableModeChanged();

  private:
    void itemChanged(quint64 signalFlag);

  protected:
    Prefs();
    friend class PrefsHelper;

    bool usrSave() override;

    // Periodic Table
    int mSchemaPSE;
    static int defaultSchemaPSEValue_helper();
    int mColorschemebox;
    static int defaultColorschemeboxValue_helper();
    int mGradient;
    static int defaultGradientValue_helper();
    int mNumeration;
    static int defaultNumerationValue_helper();
    bool mShowlegend;
    static bool defaultShowlegendValue_helper();
    int mPselook;
    static int defaultPselookValue_helper();
    int mTable;
    static int defaultTableValue_helper();

    // Logarithmic Gradients
    bool mLogarithmicCovalentRadiusGradient;
    static bool defaultLogarithmicCovalentRadiusGradientValue_helper();
    bool mLogarithmicVanDerWaalsRadiusGradient;
    static bool defaultLogarithmicVanDerWaalsRadiusGradientValue_helper();
    bool mLogarithmicMassGradient;
    static bool defaultLogarithmicMassGradientValue_helper();
    bool mLogarithmicBoilingPointGradient;
    static bool defaultLogarithmicBoilingPointGradientValue_helper();
    bool mLogarithmicMeltingPointGradient;
    static bool defaultLogarithmicMeltingPointGradientValue_helper();
    bool mLogarithmicElectronegativityGradient;
    static bool defaultLogarithmicElectronegativityGradientValue_helper();
    bool mLogarithmicDiscoverydateGradient;
    static bool defaultLogarithmicDiscoverydateGradientValue_helper();
    bool mLogarithmicElectronaffinityGradient;
    static bool defaultLogarithmicElectronaffinityGradientValue_helper();
    bool mLogarithmicIonizationGradient;
    static bool defaultLogarithmicIonizationGradientValue_helper();

    // Colors
    int mColorgradientbox;
    static int defaultColorgradientboxValue_helper();
    QColor mNoscheme;
    static QColor defaultNoschemeValue_helper();
    QColor mColor_liquid;
    static QColor defaultColor_liquidValue_helper();
    QColor mColor_solid;
    static QColor defaultColor_solidValue_helper();
    QColor mColor_vapor;
    static QColor defaultColor_vaporValue_helper();
    QColor mColor_radioactive;
    static QColor defaultColor_radioactiveValue_helper();
    QColor mColor_artificial;
    static QColor defaultColor_artificialValue_helper();
    QColor mBlock_s;
    static QColor defaultBlock_sValue_helper();
    QColor mBlock_p;
    static QColor defaultBlock_pValue_helper();
    QColor mBlock_d;
    static QColor defaultBlock_dValue_helper();
    QColor mBlock_f;
    static QColor defaultBlock_fValue_helper();
    QColor mGroup_1;
    static QColor defaultGroup_1Value_helper();
    QColor mGroup_2;
    static QColor defaultGroup_2Value_helper();
    QColor mGroup_3;
    static QColor defaultGroup_3Value_helper();
    QColor mGroup_4;
    static QColor defaultGroup_4Value_helper();
    QColor mGroup_5;
    static QColor defaultGroup_5Value_helper();
    QColor mGroup_6;
    static QColor defaultGroup_6Value_helper();
    QColor mGroup_7;
    static QColor defaultGroup_7Value_helper();
    QColor mGroup_8;
    static QColor defaultGroup_8Value_helper();
    QColor mAlkali_metal;
    static QColor defaultAlkali_metalValue_helper();
    QColor mRare;
    static QColor defaultRareValue_helper();
    QColor mNonmetal;
    static QColor defaultNonmetalValue_helper();
    QColor mAlkaline_earth_metal;
    static QColor defaultAlkaline_earth_metalValue_helper();
    QColor mOther_metal;
    static QColor defaultOther_metalValue_helper();
    QColor mHalogene;
    static QColor defaultHalogeneValue_helper();
    QColor mTransition;
    static QColor defaultTransitionValue_helper();
    QColor mNoble_gas;
    static QColor defaultNoble_gasValue_helper();
    QColor mMetalloid;
    static QColor defaultMetalloidValue_helper();
    QColor mMaxColor;
    static QColor defaultMaxColorValue_helper();
    QColor mMinColor;
    static QColor defaultMinColorValue_helper();

    // Units
    int mEnergiesUnit;
    static int defaultEnergiesUnitValue_helper();
    int mTemperatureUnit;
    static int defaultTemperatureUnitValue_helper();
    int mLengthUnit;
    static int defaultLengthUnitValue_helper();
    int mCombobox_energies;
    static int defaultCombobox_energiesValue_helper();
    int mCombobox_temperature;
    static int defaultCombobox_temperatureValue_helper();
    int mCombobox_length;
    static int defaultCombobox_lengthValue_helper();
    bool mSchemaSelected;
    static bool defaultSchemaSelectedValue_helper();

    // Spectrum
    int mSpectrumWavelengthUnit;
    static int defaultSpectrumWavelengthUnitValue_helper();
    int mSpectrumType;
    static int defaultSpectrumTypeValue_helper();

    // Calculator
    bool mMass;
    static bool defaultMassValue_helper();
    bool mIdeal;
    static bool defaultIdealValue_helper();
    bool mSoluteMass;
    static bool defaultSoluteMassValue_helper();
    bool mSolventVolume;
    static bool defaultSolventVolumeValue_helper();
    bool mAlias;
    static bool defaultAliasValue_helper();
    bool mAddAlias;
    static bool defaultAddAliasValue_helper();

    // Sidebar
    bool mShowsidebar;
    static bool defaultShowsidebarValue_helper();

    // Isotope Table
    int mIsotopeTableMode;
    static int defaultIsotopeTableModeValue_helper();

  private:
    QSet<quint64> mSettingsChanged;
};

#endif

