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

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

class StatsPluginSettings : public KConfigSkeleton
{
  public:

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

    /**
      Set Update charts every n gui updates
    */
    static
    void setUpdateEveryGuiUpdates( uint v )
    {
      if (!self()->isUpdateEveryGuiUpdatesImmutable())
        self()->mUpdateEveryGuiUpdates = v;
    }

    /**
      Get Update charts every n gui updates
    */
    static
    uint updateEveryGuiUpdates()
    {
      return self()->mUpdateEveryGuiUpdates;
    }

    /**
      Is Update charts every n gui updates Immutable
    */
    static
    bool isUpdateEveryGuiUpdatesImmutable()
    {
      return self()->isImmutable( QStringLiteral( "UpdateEveryGuiUpdates" ) );
    }

    /**
      Set Interval in milliseconds between data gathering
    */
    static
    void setDataGatherIval( uint v )
    {
      if (!self()->isDataGatherIvalImmutable())
        self()->mDataGatherIval = v;
    }

    /**
      Get Interval in milliseconds between data gathering
    */
    static
    uint dataGatherIval()
    {
      return self()->mDataGatherIval;
    }

    /**
      Is Interval in milliseconds between data gathering Immutable
    */
    static
    bool isDataGatherIvalImmutable()
    {
      return self()->isImmutable( QStringLiteral( "DataGatherIval" ) );
    }

    /**
      Set Method of determining maximum value of the scale
    */
    static
    void setMaxMode( uint v )
    {
      if (!self()->isMaxModeImmutable())
        self()->mMaxMode = v;
    }

    /**
      Get Method of determining maximum value of the scale
    */
    static
    uint maxMode()
    {
      return self()->mMaxMode;
    }

    /**
      Is Method of determining maximum value of the scale Immutable
    */
    static
    bool isMaxModeImmutable()
    {
      return self()->isImmutable( QStringLiteral( "MaxMode" ) );
    }

    /**
      Set Whether to show seeds in swarms
    */
    static
    void setShowSeedsInSwarms( bool v )
    {
      if (!self()->isShowSeedsInSwarmsImmutable())
        self()->mShowSeedsInSwarms = v;
    }

    /**
      Get Whether to show seeds in swarms
    */
    static
    bool showSeedsInSwarms()
    {
      return self()->mShowSeedsInSwarms;
    }

    /**
      Is Whether to show seeds in swarms Immutable
    */
    static
    bool isShowSeedsInSwarmsImmutable()
    {
      return self()->isImmutable( QStringLiteral( "ShowSeedsInSwarms" ) );
    }

    /**
      Set Whether to show leachers in swarms
    */
    static
    void setShowLeechersInSwarms( bool v )
    {
      if (!self()->isShowLeechersInSwarmsImmutable())
        self()->mShowLeechersInSwarms = v;
    }

    /**
      Get Whether to show leachers in swarms
    */
    static
    bool showLeechersInSwarms()
    {
      return self()->mShowLeechersInSwarms;
    }

    /**
      Is Whether to show leachers in swarms Immutable
    */
    static
    bool isShowLeechersInSwarmsImmutable()
    {
      return self()->isImmutable( QStringLiteral( "ShowLeechersInSwarms" ) );
    }

    /**
      Set Samples to show on download chart
    */
    static
    void setDlSpdSamples( uint v )
    {
      if (!self()->isDlSpdSamplesImmutable())
        self()->mDlSpdSamples = v;
    }

    /**
      Get Samples to show on download chart
    */
    static
    uint dlSpdSamples()
    {
      return self()->mDlSpdSamples;
    }

    /**
      Is Samples to show on download chart Immutable
    */
    static
    bool isDlSpdSamplesImmutable()
    {
      return self()->isImmutable( QStringLiteral( "DlSpdSamples" ) );
    }

    /**
      Set Samples to show on peers chart
    */
    static
    void setPeersSpdSamples( uint v )
    {
      if (!self()->isPeersSpdSamplesImmutable())
        self()->mPeersSpdSamples = v;
    }

    /**
      Get Samples to show on peers chart
    */
    static
    uint peersSpdSamples()
    {
      return self()->mPeersSpdSamples;
    }

    /**
      Is Samples to show on peers chart Immutable
    */
    static
    bool isPeersSpdSamplesImmutable()
    {
      return self()->isImmutable( QStringLiteral( "PeersSpdSamples" ) );
    }

    /**
      Set Samples to show on upload chart
    */
    static
    void setUlSpdSamples( uint v )
    {
      if (!self()->isUlSpdSamplesImmutable())
        self()->mUlSpdSamples = v;
    }

    /**
      Get Samples to show on upload chart
    */
    static
    uint ulSpdSamples()
    {
      return self()->mUlSpdSamples;
    }

    /**
      Is Samples to show on upload chart Immutable
    */
    static
    bool isUlSpdSamplesImmutable()
    {
      return self()->isImmutable( QStringLiteral( "UlSpdSamples" ) );
    }

    /**
      Set Samples to show on connections chart
    */
    static
    void setConnsSamples( uint v )
    {
      if (!self()->isConnsSamplesImmutable())
        self()->mConnsSamples = v;
    }

    /**
      Get Samples to show on connections chart
    */
    static
    uint connsSamples()
    {
      return self()->mConnsSamples;
    }

    /**
      Is Samples to show on connections chart Immutable
    */
    static
    bool isConnsSamplesImmutable()
    {
      return self()->isImmutable( QStringLiteral( "ConnsSamples" ) );
    }

    /**
      Set Samples to show on DHT chart
    */
    static
    void setDhtSpdSamples( uint v )
    {
      if (!self()->isDhtSpdSamplesImmutable())
        self()->mDhtSpdSamples = v;
    }

    /**
      Get Samples to show on DHT chart
    */
    static
    uint dhtSpdSamples()
    {
      return self()->mDhtSpdSamples;
    }

    /**
      Is Samples to show on DHT chart Immutable
    */
    static
    bool isDhtSpdSamplesImmutable()
    {
      return self()->isImmutable( QStringLiteral( "DhtSpdSamples" ) );
    }

    /**
      Set Color of the speed on dl chart
    */
    static
    void setDlSpdColor( const QColor & v )
    {
      if (!self()->isDlSpdColorImmutable())
        self()->mDlSpdColor = v;
    }

    /**
      Get Color of the speed on dl chart
    */
    static
    QColor dlSpdColor()
    {
      return self()->mDlSpdColor;
    }

    /**
      Is Color of the speed on dl chart Immutable
    */
    static
    bool isDlSpdColorImmutable()
    {
      return self()->isImmutable( QStringLiteral( "DlSpdColor" ) );
    }

    /**
      Set Color of the average on dl chart
    */
    static
    void setDlAvgColor( const QColor & v )
    {
      if (!self()->isDlAvgColorImmutable())
        self()->mDlAvgColor = v;
    }

    /**
      Get Color of the average on dl chart
    */
    static
    QColor dlAvgColor()
    {
      return self()->mDlAvgColor;
    }

    /**
      Is Color of the average on dl chart Immutable
    */
    static
    bool isDlAvgColorImmutable()
    {
      return self()->isImmutable( QStringLiteral( "DlAvgColor" ) );
    }

    /**
      Set Color of the limit on dl chart
    */
    static
    void setDlLimitColor( const QColor & v )
    {
      if (!self()->isDlLimitColorImmutable())
        self()->mDlLimitColor = v;
    }

    /**
      Get Color of the limit on dl chart
    */
    static
    QColor dlLimitColor()
    {
      return self()->mDlLimitColor;
    }

    /**
      Is Color of the limit on dl chart Immutable
    */
    static
    bool isDlLimitColorImmutable()
    {
      return self()->isImmutable( QStringLiteral( "DlLimitColor" ) );
    }

    /**
      Set Color of the avg from leecher on peers chart
    */
    static
    void setPrAvgFromLColor( const QColor & v )
    {
      if (!self()->isPrAvgFromLColorImmutable())
        self()->mPrAvgFromLColor = v;
    }

    /**
      Get Color of the avg from leecher on peers chart
    */
    static
    QColor prAvgFromLColor()
    {
      return self()->mPrAvgFromLColor;
    }

    /**
      Is Color of the avg from leecher on peers chart Immutable
    */
    static
    bool isPrAvgFromLColorImmutable()
    {
      return self()->isImmutable( QStringLiteral( "PrAvgFromLColor" ) );
    }

    /**
      Set Color of the avg to leecher on peers chart
    */
    static
    void setPrAvgToLColor( const QColor & v )
    {
      if (!self()->isPrAvgToLColorImmutable())
        self()->mPrAvgToLColor = v;
    }

    /**
      Get Color of the avg to leecher on peers chart
    */
    static
    QColor prAvgToLColor()
    {
      return self()->mPrAvgToLColor;
    }

    /**
      Is Color of the avg to leecher on peers chart Immutable
    */
    static
    bool isPrAvgToLColorImmutable()
    {
      return self()->isImmutable( QStringLiteral( "PrAvgToLColor" ) );
    }

    /**
      Set Color of the avg from seeds on peers chart
    */
    static
    void setPrAvgFromSColor( const QColor & v )
    {
      if (!self()->isPrAvgFromSColorImmutable())
        self()->mPrAvgFromSColor = v;
    }

    /**
      Get Color of the avg from seeds on peers chart
    */
    static
    QColor prAvgFromSColor()
    {
      return self()->mPrAvgFromSColor;
    }

    /**
      Is Color of the avg from seeds on peers chart Immutable
    */
    static
    bool isPrAvgFromSColorImmutable()
    {
      return self()->isImmutable( QStringLiteral( "PrAvgFromSColor" ) );
    }

    /**
      Set Color of the leechers on peers chart
    */
    static
    void setPrFromLColor( const QColor & v )
    {
      if (!self()->isPrFromLColorImmutable())
        self()->mPrFromLColor = v;
    }

    /**
      Get Color of the leechers on peers chart
    */
    static
    QColor prFromLColor()
    {
      return self()->mPrFromLColor;
    }

    /**
      Is Color of the leechers on peers chart Immutable
    */
    static
    bool isPrFromLColorImmutable()
    {
      return self()->isImmutable( QStringLiteral( "PrFromLColor" ) );
    }

    /**
      Set Color of the seeds on peers chart
    */
    static
    void setPrFromSColor( const QColor & v )
    {
      if (!self()->isPrFromSColorImmutable())
        self()->mPrFromSColor = v;
    }

    /**
      Get Color of the seeds on peers chart
    */
    static
    QColor prFromSColor()
    {
      return self()->mPrFromSColor;
    }

    /**
      Is Color of the seeds on peers chart Immutable
    */
    static
    bool isPrFromSColorImmutable()
    {
      return self()->isImmutable( QStringLiteral( "PrFromSColor" ) );
    }

    /**
      Set Color of the speed on upload chart
    */
    static
    void setUlSpdColor( const QColor & v )
    {
      if (!self()->isUlSpdColorImmutable())
        self()->mUlSpdColor = v;
    }

    /**
      Get Color of the speed on upload chart
    */
    static
    QColor ulSpdColor()
    {
      return self()->mUlSpdColor;
    }

    /**
      Is Color of the speed on upload chart Immutable
    */
    static
    bool isUlSpdColorImmutable()
    {
      return self()->isImmutable( QStringLiteral( "UlSpdColor" ) );
    }

    /**
      Set Color of the avg on upload chart
    */
    static
    void setUlAvgColor( const QColor & v )
    {
      if (!self()->isUlAvgColorImmutable())
        self()->mUlAvgColor = v;
    }

    /**
      Get Color of the avg on upload chart
    */
    static
    QColor ulAvgColor()
    {
      return self()->mUlAvgColor;
    }

    /**
      Is Color of the avg on upload chart Immutable
    */
    static
    bool isUlAvgColorImmutable()
    {
      return self()->isImmutable( QStringLiteral( "UlAvgColor" ) );
    }

    /**
      Set Color of the limit on upload chart
    */
    static
    void setUlLimitColor( const QColor & v )
    {
      if (!self()->isUlLimitColorImmutable())
        self()->mUlLimitColor = v;
    }

    /**
      Get Color of the limit on upload chart
    */
    static
    QColor ulLimitColor()
    {
      return self()->mUlLimitColor;
    }

    /**
      Is Color of the limit on upload chart Immutable
    */
    static
    bool isUlLimitColorImmutable()
    {
      return self()->isImmutable( QStringLiteral( "UlLimitColor" ) );
    }

    /**
      Set Color of the connected leechers on connections chart
    */
    static
    void setCnLConnColor( const QColor & v )
    {
      if (!self()->isCnLConnColorImmutable())
        self()->mCnLConnColor = v;
    }

    /**
      Get Color of the connected leechers on connections chart
    */
    static
    QColor cnLConnColor()
    {
      return self()->mCnLConnColor;
    }

    /**
      Is Color of the connected leechers on connections chart Immutable
    */
    static
    bool isCnLConnColorImmutable()
    {
      return self()->isImmutable( QStringLiteral( "CnLConnColor" ) );
    }

    /**
      Set Color of the leechers in swarms on connections chart
    */
    static
    void setCnLSwarmsColor( const QColor & v )
    {
      if (!self()->isCnLSwarmsColorImmutable())
        self()->mCnLSwarmsColor = v;
    }

    /**
      Get Color of the leechers in swarms on connections chart
    */
    static
    QColor cnLSwarmsColor()
    {
      return self()->mCnLSwarmsColor;
    }

    /**
      Is Color of the leechers in swarms on connections chart Immutable
    */
    static
    bool isCnLSwarmsColorImmutable()
    {
      return self()->isImmutable( QStringLiteral( "CnLSwarmsColor" ) );
    }

    /**
      Set Color of the connected seeds on connections chart
    */
    static
    void setCnSConnColor( const QColor & v )
    {
      if (!self()->isCnSConnColorImmutable())
        self()->mCnSConnColor = v;
    }

    /**
      Get Color of the connected seeds on connections chart
    */
    static
    QColor cnSConnColor()
    {
      return self()->mCnSConnColor;
    }

    /**
      Is Color of the connected seeds on connections chart Immutable
    */
    static
    bool isCnSConnColorImmutable()
    {
      return self()->isImmutable( QStringLiteral( "CnSConnColor" ) );
    }

    /**
      Set Color of the seeds in swarms on connections chart
    */
    static
    void setCnSSwarmsColor( const QColor & v )
    {
      if (!self()->isCnSSwarmsColorImmutable())
        self()->mCnSSwarmsColor = v;
    }

    /**
      Get Color of the seeds in swarms on connections chart
    */
    static
    QColor cnSSwarmsColor()
    {
      return self()->mCnSSwarmsColor;
    }

    /**
      Is Color of the seeds in swarms on connections chart Immutable
    */
    static
    bool isCnSSwarmsColorImmutable()
    {
      return self()->isImmutable( QStringLiteral( "CnSSwarmsColor" ) );
    }

    /**
      Set Color of the avg connected leecher per torrent on connections chart
    */
    static
    void setCnAvgLConnPerTorrColor( const QColor & v )
    {
      if (!self()->isCnAvgLConnPerTorrColorImmutable())
        self()->mCnAvgLConnPerTorrColor = v;
    }

    /**
      Get Color of the avg connected leecher per torrent on connections chart
    */
    static
    QColor cnAvgLConnPerTorrColor()
    {
      return self()->mCnAvgLConnPerTorrColor;
    }

    /**
      Is Color of the avg connected leecher per torrent on connections chart Immutable
    */
    static
    bool isCnAvgLConnPerTorrColorImmutable()
    {
      return self()->isImmutable( QStringLiteral( "CnAvgLConnPerTorrColor" ) );
    }

    /**
      Set Color of the avg connected seeds per torrent on connections chart
    */
    static
    void setCnAvgSConnPerTorrColor( const QColor & v )
    {
      if (!self()->isCnAvgSConnPerTorrColorImmutable())
        self()->mCnAvgSConnPerTorrColor = v;
    }

    /**
      Get Color of the avg connected seeds per torrent on connections chart
    */
    static
    QColor cnAvgSConnPerTorrColor()
    {
      return self()->mCnAvgSConnPerTorrColor;
    }

    /**
      Is Color of the avg connected seeds per torrent on connections chart Immutable
    */
    static
    bool isCnAvgSConnPerTorrColorImmutable()
    {
      return self()->isImmutable( QStringLiteral( "CnAvgSConnPerTorrColor" ) );
    }

    /**
      Set Color of the avg connected leechers per running torrent on connections chart
    */
    static
    void setCnAvgLConnPerRunTorrColor( const QColor & v )
    {
      if (!self()->isCnAvgLConnPerRunTorrColorImmutable())
        self()->mCnAvgLConnPerRunTorrColor = v;
    }

    /**
      Get Color of the avg connected leechers per running torrent on connections chart
    */
    static
    QColor cnAvgLConnPerRunTorrColor()
    {
      return self()->mCnAvgLConnPerRunTorrColor;
    }

    /**
      Is Color of the avg connected leechers per running torrent on connections chart Immutable
    */
    static
    bool isCnAvgLConnPerRunTorrColorImmutable()
    {
      return self()->isImmutable( QStringLiteral( "CnAvgLConnPerRunTorrColor" ) );
    }

    /**
      Set Color of the avg connected seeds per running torrent on connections chart
    */
    static
    void setCnAvgSConnPerRunTorrColor( const QColor & v )
    {
      if (!self()->isCnAvgSConnPerRunTorrColorImmutable())
        self()->mCnAvgSConnPerRunTorrColor = v;
    }

    /**
      Get Color of the avg connected seeds per running torrent on connections chart
    */
    static
    QColor cnAvgSConnPerRunTorrColor()
    {
      return self()->mCnAvgSConnPerRunTorrColor;
    }

    /**
      Is Color of the avg connected seeds per running torrent on connections chart Immutable
    */
    static
    bool isCnAvgSConnPerRunTorrColorImmutable()
    {
      return self()->isImmutable( QStringLiteral( "CnAvgSConnPerRunTorrColor" ) );
    }

    /**
      Set Color of the nodes on DHT chart
    */
    static
    void setDhtNodesColor( const QColor & v )
    {
      if (!self()->isDhtNodesColorImmutable())
        self()->mDhtNodesColor = v;
    }

    /**
      Get Color of the nodes on DHT chart
    */
    static
    QColor dhtNodesColor()
    {
      return self()->mDhtNodesColor;
    }

    /**
      Is Color of the nodes on DHT chart Immutable
    */
    static
    bool isDhtNodesColorImmutable()
    {
      return self()->isImmutable( QStringLiteral( "DhtNodesColor" ) );
    }

    /**
      Set Color of the tasks on DHT chart
    */
    static
    void setDhtTasksColor( const QColor & v )
    {
      if (!self()->isDhtTasksColorImmutable())
        self()->mDhtTasksColor = v;
    }

    /**
      Get Color of the tasks on DHT chart
    */
    static
    QColor dhtTasksColor()
    {
      return self()->mDhtTasksColor;
    }

    /**
      Is Color of the tasks on DHT chart Immutable
    */
    static
    bool isDhtTasksColorImmutable()
    {
      return self()->isImmutable( QStringLiteral( "DhtTasksColor" ) );
    }

    /**
      Set Use anti aliasing on charts?
    */
    static
    void setAntiAliasing( bool v )
    {
      if (!self()->isAntiAliasingImmutable())
        self()->mAntiAliasing = v;
    }

    /**
      Get Use anti aliasing on charts?
    */
    static
    bool antiAliasing()
    {
      return self()->mAntiAliasing;
    }

    /**
      Is Use anti aliasing on charts? Immutable
    */
    static
    bool isAntiAliasingImmutable()
    {
      return self()->isImmutable( QStringLiteral( "AntiAliasing" ) );
    }

    /**
      Set Draw ugly grey background grid?
    */
    static
    void setDrawBgdGrid( bool v )
    {
      if (!self()->isDrawBgdGridImmutable())
        self()->mDrawBgdGrid = v;
    }

    /**
      Get Draw ugly grey background grid?
    */
    static
    bool drawBgdGrid()
    {
      return self()->mDrawBgdGrid;
    }

    /**
      Is Draw ugly grey background grid? Immutable
    */
    static
    bool isDrawBgdGridImmutable()
    {
      return self()->isImmutable( QStringLiteral( "DrawBgdGrid" ) );
    }

    /**
      Set Type of widget used for chart drawing
    */
    static
    void setWidgetType( uint v )
    {
      if (!self()->isWidgetTypeImmutable())
        self()->mWidgetType = v;
    }

    /**
      Get Type of widget used for chart drawing
    */
    static
    uint widgetType()
    {
      return self()->mWidgetType;
    }

    /**
      Is Type of widget used for chart drawing Immutable
    */
    static
    bool isWidgetTypeImmutable()
    {
      return self()->isImmutable( QStringLiteral( "WidgetType" ) );
    }

  protected:
    StatsPluginSettings();
    friend class StatsPluginSettingsHelper;


    // general
    uint mUpdateEveryGuiUpdates;
    uint mDataGatherIval;
    uint mMaxMode;
    bool mShowSeedsInSwarms;
    bool mShowLeechersInSwarms;
    uint mDlSpdSamples;
    uint mPeersSpdSamples;
    uint mUlSpdSamples;
    uint mConnsSamples;
    uint mDhtSpdSamples;
    QColor mDlSpdColor;
    QColor mDlAvgColor;
    QColor mDlLimitColor;
    QColor mPrAvgFromLColor;
    QColor mPrAvgToLColor;
    QColor mPrAvgFromSColor;
    QColor mPrFromLColor;
    QColor mPrFromSColor;
    QColor mUlSpdColor;
    QColor mUlAvgColor;
    QColor mUlLimitColor;
    QColor mCnLConnColor;
    QColor mCnLSwarmsColor;
    QColor mCnSConnColor;
    QColor mCnSSwarmsColor;
    QColor mCnAvgLConnPerTorrColor;
    QColor mCnAvgSConnPerTorrColor;
    QColor mCnAvgLConnPerRunTorrColor;
    QColor mCnAvgSConnPerRunTorrColor;
    QColor mDhtNodesColor;
    QColor mDhtTasksColor;
    bool mAntiAliasing;
    bool mDrawBgdGrid;
    uint mWidgetType;
};

#endif

