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

#include <akregatorinterfaces_export.h>

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

namespace Akregator {

class AKREGATORINTERFACES_EXPORT Settings : public KConfigSkeleton
{
  public:
    class EnumArchiveMode
    {
      public:
      enum type { keepAllArticles, limitArticleNumber, limitArticleAge, disableArchiving, COUNT };
    };
    class EnumLMBBehaviour
    {
      public:
      enum type { OpenInInternalBrowser, OpenInBackground, OpenInExternalBrowser, COUNT };
    };
    class EnumMMBBehaviour
    {
      public:
      enum type { OpenInInternalBrowser, OpenInBackground, OpenInExternalBrowser, COUNT };
    };

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

    /**
      Set Hide feeds with no unread articles
    */
    static
    void setHideReadFeeds( bool v )
    {
      if (!self()->isHideReadFeedsImmutable())
        self()->mHideReadFeeds = v;
    }

    /**
      Get Hide feeds with no unread articles
    */
    static
    bool hideReadFeeds()
    {
      return self()->mHideReadFeeds;
    }

    /**
      Is Hide feeds with no unread articles Immutable
    */
    static
    bool isHideReadFeedsImmutable()
    {
      return self()->isImmutable( QStringLiteral( "HideReadFeeds" ) );
    }

    /**
      Set ShowMenuBar
    */
    static
    void setShowMenuBar( bool v )
    {
      if (!self()->isShowMenuBarImmutable())
        self()->mShowMenuBar = v;
    }

    /**
      Get ShowMenuBar
    */
    static
    bool showMenuBar()
    {
      return self()->mShowMenuBar;
    }

    /**
      Is ShowMenuBar Immutable
    */
    static
    bool isShowMenuBarImmutable()
    {
      return self()->isImmutable( QStringLiteral( "ShowMenuBar" ) );
    }

    /**
      Set Prevent feeds from being moved in the list
    */
    static
    void setLockFeedsInPlace( bool v )
    {
      if (!self()->isLockFeedsInPlaceImmutable())
        self()->mLockFeedsInPlace = v;
    }

    /**
      Get Prevent feeds from being moved in the list
    */
    static
    bool lockFeedsInPlace()
    {
      return self()->mLockFeedsInPlace;
    }

    /**
      Is Prevent feeds from being moved in the list Immutable
    */
    static
    bool isLockFeedsInPlaceImmutable()
    {
      return self()->isImmutable( QStringLiteral( "LockFeedsInPlace" ) );
    }

    /**
      Set Auto-Expand folders with unread articles
    */
    static
    void setAutoExpandFolders( bool v )
    {
      if (!self()->isAutoExpandFoldersImmutable())
        self()->mAutoExpandFolders = v;
    }

    /**
      Get Auto-Expand folders with unread articles
    */
    static
    bool autoExpandFolders()
    {
      return self()->mAutoExpandFolders;
    }

    /**
      Is Auto-Expand folders with unread articles Immutable
    */
    static
    bool isAutoExpandFoldersImmutable()
    {
      return self()->isImmutable( QStringLiteral( "AutoExpandFolders" ) );
    }

    /**
      Set Show Quick Filter
    */
    static
    void setShowQuickFilter( bool v )
    {
      if (!self()->isShowQuickFilterImmutable())
        self()->mShowQuickFilter = v;
    }

    /**
      Get Show Quick Filter
    */
    static
    bool showQuickFilter()
    {
      return self()->mShowQuickFilter;
    }

    /**
      Is Show Quick Filter Immutable
    */
    static
    bool isShowQuickFilterImmutable()
    {
      return self()->isImmutable( QStringLiteral( "ShowQuickFilter" ) );
    }

    /**
      Set Status Filter
    */
    static
    void setStatusFilter( int v )
    {
      if (!self()->isStatusFilterImmutable())
        self()->mStatusFilter = v;
    }

    /**
      Get Status Filter
    */
    static
    int statusFilter()
    {
      return self()->mStatusFilter;
    }

    /**
      Is Status Filter Immutable
    */
    static
    bool isStatusFilterImmutable()
    {
      return self()->isImmutable( QStringLiteral( "StatusFilter" ) );
    }

    /**
      Set Text Filter
    */
    static
    void setTextFilter( const QString & v )
    {
      if (!self()->isTextFilterImmutable())
        self()->mTextFilter = v;
    }

    /**
      Get Text Filter
    */
    static
    QString textFilter()
    {
      return self()->mTextFilter;
    }

    /**
      Is Text Filter Immutable
    */
    static
    bool isTextFilterImmutable()
    {
      return self()->isImmutable( QStringLiteral( "TextFilter" ) );
    }

    /**
      Set View Mode
    */
    static
    void setViewMode( int v )
    {
      if (!self()->isViewModeImmutable())
        self()->mViewMode = v;
    }

    /**
      Get View Mode
    */
    static
    int viewMode()
    {
      return self()->mViewMode;
    }

    /**
      Is View Mode Immutable
    */
    static
    bool isViewModeImmutable()
    {
      return self()->isImmutable( QStringLiteral( "ViewMode" ) );
    }

    /**
      Set Sizes for first splitter
    */
    static
    void setSplitter1Sizes( const QList<int> & v )
    {
      if (!self()->isSplitter1SizesImmutable())
        self()->mSplitter1Sizes = v;
    }

    /**
      Get Sizes for first splitter
    */
    static
    QList<int> splitter1Sizes()
    {
      return self()->mSplitter1Sizes;
    }

    /**
      Is Sizes for first splitter Immutable
    */
    static
    bool isSplitter1SizesImmutable()
    {
      return self()->isImmutable( QStringLiteral( "Splitter1Sizes" ) );
    }

    /**
      Set Sizes for second splitter
    */
    static
    void setSplitter2Sizes( const QList<int> & v )
    {
      if (!self()->isSplitter2SizesImmutable())
        self()->mSplitter2Sizes = v;
    }

    /**
      Get Sizes for second splitter
    */
    static
    QList<int> splitter2Sizes()
    {
      return self()->mSplitter2Sizes;
    }

    /**
      Is Sizes for second splitter Immutable
    */
    static
    bool isSplitter2SizesImmutable()
    {
      return self()->isImmutable( QStringLiteral( "Splitter2Sizes" ) );
    }

    /**
      Set CheckPhishingUrl
    */
    static
    void setCheckPhishingUrl( bool v )
    {
      if (!self()->isCheckPhishingUrlImmutable())
        self()->mCheckPhishingUrl = v;
    }

    /**
      Get CheckPhishingUrl
    */
    static
    bool checkPhishingUrl()
    {
      return self()->mCheckPhishingUrl;
    }

    /**
      Is CheckPhishingUrl Immutable
    */
    static
    bool isCheckPhishingUrlImmutable()
    {
      return self()->isImmutable( QStringLiteral( "CheckPhishingUrl" ) );
    }

    /**
      Set LoadExternalReferences
    */
    static
    void setLoadExternalReferences( bool v )
    {
      if (!self()->isLoadExternalReferencesImmutable())
        self()->mLoadExternalReferences = v;
    }

    /**
      Get LoadExternalReferences
    */
    static
    bool loadExternalReferences()
    {
      return self()->mLoadExternalReferences;
    }

    /**
      Is LoadExternalReferences Immutable
    */
    static
    bool isLoadExternalReferencesImmutable()
    {
      return self()->isImmutable( QStringLiteral( "LoadExternalReferences" ) );
    }

    /**
      Set Standard Font
    */
    static
    void setStandardFont( const QString & v )
    {
      if (!self()->isStandardFontImmutable())
        self()->mStandardFont = v;
    }

    /**
      Get Standard Font
    */
    static
    QString standardFont()
    {
      return self()->mStandardFont;
    }

    /**
      Is Standard Font Immutable
    */
    static
    bool isStandardFontImmutable()
    {
      return self()->isImmutable( QStringLiteral( "StandardFont" ) );
    }

    /**
      Set Fixed Font
    */
    static
    void setFixedFont( const QString & v )
    {
      if (!self()->isFixedFontImmutable())
        self()->mFixedFont = v;
    }

    /**
      Get Fixed Font
    */
    static
    QString fixedFont()
    {
      return self()->mFixedFont;
    }

    /**
      Is Fixed Font Immutable
    */
    static
    bool isFixedFontImmutable()
    {
      return self()->isImmutable( QStringLiteral( "FixedFont" ) );
    }

    /**
      Set Serif Font
    */
    static
    void setSerifFont( const QString & v )
    {
      if (!self()->isSerifFontImmutable())
        self()->mSerifFont = v;
    }

    /**
      Get Serif Font
    */
    static
    QString serifFont()
    {
      return self()->mSerifFont;
    }

    /**
      Is Serif Font Immutable
    */
    static
    bool isSerifFontImmutable()
    {
      return self()->isImmutable( QStringLiteral( "SerifFont" ) );
    }

    /**
      Set Sans Serif Font
    */
    static
    void setSansSerifFont( const QString & v )
    {
      if (!self()->isSansSerifFontImmutable())
        self()->mSansSerifFont = v;
    }

    /**
      Get Sans Serif Font
    */
    static
    QString sansSerifFont()
    {
      return self()->mSansSerifFont;
    }

    /**
      Is Sans Serif Font Immutable
    */
    static
    bool isSansSerifFontImmutable()
    {
      return self()->isImmutable( QStringLiteral( "SansSerifFont" ) );
    }

    /**
      Set UseCustomColors
    */
    static
    void setUseCustomColors( bool v )
    {
      if (!self()->isUseCustomColorsImmutable())
        self()->mUseCustomColors = v;
    }

    /**
      Get UseCustomColors
    */
    static
    bool useCustomColors()
    {
      return self()->mUseCustomColors;
    }

    /**
      Is UseCustomColors Immutable
    */
    static
    bool isUseCustomColorsImmutable()
    {
      return self()->isImmutable( QStringLiteral( "UseCustomColors" ) );
    }

    /**
      Set ColorUnreadArticles
    */
    static
    void setColorUnreadArticles( const QColor & v )
    {
      if (!self()->isColorUnreadArticlesImmutable())
        self()->mColorUnreadArticles = v;
    }

    /**
      Get ColorUnreadArticles
    */
    static
    QColor colorUnreadArticles()
    {
      return self()->mColorUnreadArticles;
    }

    /**
      Is ColorUnreadArticles Immutable
    */
    static
    bool isColorUnreadArticlesImmutable()
    {
      return self()->isImmutable( QStringLiteral( "ColorUnreadArticles" ) );
    }

    /**
      Set ColorNewArticles
    */
    static
    void setColorNewArticles( const QColor & v )
    {
      if (!self()->isColorNewArticlesImmutable())
        self()->mColorNewArticles = v;
    }

    /**
      Get ColorNewArticles
    */
    static
    QColor colorNewArticles()
    {
      return self()->mColorNewArticles;
    }

    /**
      Is ColorNewArticles Immutable
    */
    static
    bool isColorNewArticlesImmutable()
    {
      return self()->isImmutable( QStringLiteral( "ColorNewArticles" ) );
    }

    /**
      Set Fonts
    */
    static
    void setFonts( const QStringList & v )
    {
      if (!self()->isFontsImmutable())
        self()->mFonts = v;
    }

    /**
      Get Fonts
    */
    static
    QStringList fonts()
    {
      return self()->mFonts;
    }

    /**
      Is Fonts Immutable
    */
    static
    bool isFontsImmutable()
    {
      return self()->isImmutable( QStringLiteral( "Fonts" ) );
    }

    /**
      Set MediumFontSize
    */
    static
    void setMediumFontSize( int v )
    {
      if (!self()->isMediumFontSizeImmutable())
        self()->mMediumFontSize = v;
    }

    /**
      Get MediumFontSize
    */
    static
    int mediumFontSize()
    {
      return self()->mMediumFontSize;
    }

    /**
      Is MediumFontSize Immutable
    */
    static
    bool isMediumFontSizeImmutable()
    {
      return self()->isImmutable( QStringLiteral( "MediumFontSize" ) );
    }

    /**
      Set MinimumFontSize
    */
    static
    void setMinimumFontSize( int v )
    {
      if (!self()->isMinimumFontSizeImmutable())
        self()->mMinimumFontSize = v;
    }

    /**
      Get MinimumFontSize
    */
    static
    int minimumFontSize()
    {
      return self()->mMinimumFontSize;
    }

    /**
      Is MinimumFontSize Immutable
    */
    static
    bool isMinimumFontSizeImmutable()
    {
      return self()->isImmutable( QStringLiteral( "MinimumFontSize" ) );
    }

    /**
      Set AccessKeyEnabled
    */
    static
    void setAccessKeyEnabled( bool v )
    {
      if (!self()->isAccessKeyEnabledImmutable())
        self()->mAccessKeyEnabled = v;
    }

    /**
      Get AccessKeyEnabled
    */
    static
    bool accessKeyEnabled()
    {
      return self()->mAccessKeyEnabled;
    }

    /**
      Is AccessKeyEnabled Immutable
    */
    static
    bool isAccessKeyEnabledImmutable()
    {
      return self()->isImmutable( QStringLiteral( "AccessKeyEnabled" ) );
    }

    /**
      Set Archive Mode
    */
    static
    void setArchiveMode( int v )
    {
      if (!self()->isArchiveModeImmutable())
        self()->mArchiveMode = v;
    }

    /**
      Get Archive Mode
    */
    static
    int archiveMode()
    {
      return self()->mArchiveMode;
    }

    /**
      Is Archive Mode Immutable
    */
    static
    bool isArchiveModeImmutable()
    {
      return self()->isImmutable( QStringLiteral( "ArchiveMode" ) );
    }

    /**
      Set Expiry Age
    */
    static
    void setMaxArticleAge( int v )
    {
      if (!self()->isMaxArticleAgeImmutable())
        self()->mMaxArticleAge = v;
    }

    /**
      Get Expiry Age
    */
    static
    int maxArticleAge()
    {
      return self()->mMaxArticleAge;
    }

    /**
      Is Expiry Age Immutable
    */
    static
    bool isMaxArticleAgeImmutable()
    {
      return self()->isImmutable( QStringLiteral( "MaxArticleAge" ) );
    }

    /**
      Set Article Limit
    */
    static
    void setMaxArticleNumber( int v )
    {
      if (!self()->isMaxArticleNumberImmutable())
        self()->mMaxArticleNumber = v;
    }

    /**
      Get Article Limit
    */
    static
    int maxArticleNumber()
    {
      return self()->mMaxArticleNumber;
    }

    /**
      Is Article Limit Immutable
    */
    static
    bool isMaxArticleNumberImmutable()
    {
      return self()->isImmutable( QStringLiteral( "MaxArticleNumber" ) );
    }

    /**
      Set Do Not Expire Important Articles
    */
    static
    void setDoNotExpireImportantArticles( bool v )
    {
      if (!self()->isDoNotExpireImportantArticlesImmutable())
        self()->mDoNotExpireImportantArticles = v;
    }

    /**
      Get Do Not Expire Important Articles
    */
    static
    bool doNotExpireImportantArticles()
    {
      return self()->mDoNotExpireImportantArticles;
    }

    /**
      Is Do Not Expire Important Articles Immutable
    */
    static
    bool isDoNotExpireImportantArticlesImmutable()
    {
      return self()->isImmutable( QStringLiteral( "DoNotExpireImportantArticles" ) );
    }

    /**
      Set Concurrent Fetches
    */
    static
    void setConcurrentFetches( int v )
    {
      if (!self()->isConcurrentFetchesImmutable())
        self()->mConcurrentFetches = v;
    }

    /**
      Get Concurrent Fetches
    */
    static
    int concurrentFetches()
    {
      return self()->mConcurrentFetches;
    }

    /**
      Is Concurrent Fetches Immutable
    */
    static
    bool isConcurrentFetchesImmutable()
    {
      return self()->isImmutable( QStringLiteral( "ConcurrentFetches" ) );
    }

    /**
      Set Use HTML Cache
    */
    static
    void setUseHTMLCache( bool v )
    {
      if (!self()->isUseHTMLCacheImmutable())
        self()->mUseHTMLCache = v;
    }

    /**
      Get Use HTML Cache
    */
    static
    bool useHTMLCache()
    {
      return self()->mUseHTMLCache;
    }

    /**
      Is Use HTML Cache Immutable
    */
    static
    bool isUseHTMLCacheImmutable()
    {
      return self()->isImmutable( QStringLiteral( "UseHTMLCache" ) );
    }

    /**
      Set Custom UserAgent
    */
    static
    void setCustomUserAgent( const QString & v )
    {
      if (!self()->isCustomUserAgentImmutable())
        self()->mCustomUserAgent = v;
    }

    /**
      Get Custom UserAgent
    */
    static
    QString customUserAgent()
    {
      return self()->mCustomUserAgent;
    }

    /**
      Is Custom UserAgent Immutable
    */
    static
    bool isCustomUserAgentImmutable()
    {
      return self()->isImmutable( QStringLiteral( "CustomUserAgent" ) );
    }

    /**
      Set Fetch on startup
    */
    static
    void setFetchOnStartup( bool v )
    {
      if (!self()->isFetchOnStartupImmutable())
        self()->mFetchOnStartup = v;
    }

    /**
      Get Fetch on startup
    */
    static
    bool fetchOnStartup()
    {
      return self()->mFetchOnStartup;
    }

    /**
      Is Fetch on startup Immutable
    */
    static
    bool isFetchOnStartupImmutable()
    {
      return self()->isImmutable( QStringLiteral( "FetchOnStartup" ) );
    }

    /**
      Set Mark all feeds as read on startup
    */
    static
    void setMarkAllFeedsReadOnStartup( bool v )
    {
      if (!self()->isMarkAllFeedsReadOnStartupImmutable())
        self()->mMarkAllFeedsReadOnStartup = v;
    }

    /**
      Get Mark all feeds as read on startup
    */
    static
    bool markAllFeedsReadOnStartup()
    {
      return self()->mMarkAllFeedsReadOnStartup;
    }

    /**
      Is Mark all feeds as read on startup Immutable
    */
    static
    bool isMarkAllFeedsReadOnStartupImmutable()
    {
      return self()->isImmutable( QStringLiteral( "MarkAllFeedsReadOnStartup" ) );
    }

    /**
      Set Use interval fetching
    */
    static
    void setUseIntervalFetch( bool v )
    {
      if (!self()->isUseIntervalFetchImmutable())
        self()->mUseIntervalFetch = v;
    }

    /**
      Get Use interval fetching
    */
    static
    bool useIntervalFetch()
    {
      return self()->mUseIntervalFetch;
    }

    /**
      Is Use interval fetching Immutable
    */
    static
    bool isUseIntervalFetchImmutable()
    {
      return self()->isImmutable( QStringLiteral( "UseIntervalFetch" ) );
    }

    /**
      Set Interval for autofetching
    */
    static
    void setAutoFetchInterval( int v )
    {
      if (!self()->isAutoFetchIntervalImmutable())
        self()->mAutoFetchInterval = v;
    }

    /**
      Get Interval for autofetching
    */
    static
    int autoFetchInterval()
    {
      return self()->mAutoFetchInterval;
    }

    /**
      Is Interval for autofetching Immutable
    */
    static
    bool isAutoFetchIntervalImmutable()
    {
      return self()->isImmutable( QStringLiteral( "AutoFetchInterval" ) );
    }

    /**
      Set Use notifications
    */
    static
    void setUseNotifications( bool v )
    {
      if (!self()->isUseNotificationsImmutable())
        self()->mUseNotifications = v;
    }

    /**
      Get Use notifications
    */
    static
    bool useNotifications()
    {
      return self()->mUseNotifications;
    }

    /**
      Is Use notifications Immutable
    */
    static
    bool isUseNotificationsImmutable()
    {
      return self()->isImmutable( QStringLiteral( "UseNotifications" ) );
    }

    /**
      Set Show tray icon
    */
    static
    void setShowTrayIcon( bool v )
    {
      if (!self()->isShowTrayIconImmutable())
        self()->mShowTrayIcon = v;
    }

    /**
      Get Show tray icon
    */
    static
    bool showTrayIcon()
    {
      return self()->mShowTrayIcon;
    }

    /**
      Is Show tray icon Immutable
    */
    static
    bool isShowTrayIconImmutable()
    {
      return self()->isImmutable( QStringLiteral( "ShowTrayIcon" ) );
    }

    /**
      Set Show Unread In Taskbar
    */
    static
    void setShowUnreadInTaskbar( bool v )
    {
      if (!self()->isShowUnreadInTaskbarImmutable())
        self()->mShowUnreadInTaskbar = v;
    }

    /**
      Get Show Unread In Taskbar
    */
    static
    bool showUnreadInTaskbar()
    {
      return self()->mShowUnreadInTaskbar;
    }

    /**
      Is Show Unread In Taskbar Immutable
    */
    static
    bool isShowUnreadInTaskbarImmutable()
    {
      return self()->isImmutable( QStringLiteral( "ShowUnreadInTaskbar" ) );
    }

    /**
      Set Disable Introduction
    */
    static
    void setDisableIntroduction( bool v )
    {
      if (!self()->isDisableIntroductionImmutable())
        self()->mDisableIntroduction = v;
    }

    /**
      Get Disable Introduction
    */
    static
    bool disableIntroduction()
    {
      return self()->mDisableIntroduction;
    }

    /**
      Is Disable Introduction Immutable
    */
    static
    bool isDisableIntroductionImmutable()
    {
      return self()->isImmutable( QStringLiteral( "DisableIntroduction" ) );
    }

    /**
      Set Disable Save As Notification
    */
    static
    void setDisableSaveAsNotification( bool v )
    {
      if (!self()->isDisableSaveAsNotificationImmutable())
        self()->mDisableSaveAsNotification = v;
    }

    /**
      Get Disable Save As Notification
    */
    static
    bool disableSaveAsNotification()
    {
      return self()->mDisableSaveAsNotification;
    }

    /**
      Is Disable Save As Notification Immutable
    */
    static
    bool isDisableSaveAsNotificationImmutable()
    {
      return self()->isImmutable( QStringLiteral( "DisableSaveAsNotification" ) );
    }

    /**
      Set PreviousNewFeaturesMD5
    */
    static
    void setPreviousNewFeaturesMD5( const QString & v )
    {
      if (!self()->isPreviousNewFeaturesMD5Immutable())
        self()->mPreviousNewFeaturesMD5 = v;
    }

    /**
      Get PreviousNewFeaturesMD5
    */
    static
    QString previousNewFeaturesMD5()
    {
      return self()->mPreviousNewFeaturesMD5;
    }

    /**
      Is PreviousNewFeaturesMD5 Immutable
    */
    static
    bool isPreviousNewFeaturesMD5Immutable()
    {
      return self()->isImmutable( QStringLiteral( "PreviousNewFeaturesMD5" ) );
    }

    /**
      Set Enabled Plasma Activity
    */
    static
    void setPlasmaActivitySupport( bool v )
    {
      if (!self()->isPlasmaActivitySupportImmutable())
        self()->mPlasmaActivitySupport = v;
    }

    /**
      Get Enabled Plasma Activity
    */
    static
    bool plasmaActivitySupport()
    {
      return self()->mPlasmaActivitySupport;
    }

    /**
      Is Enabled Plasma Activity Immutable
    */
    static
    bool isPlasmaActivitySupportImmutable()
    {
      return self()->isImmutable( QStringLiteral( "PlasmaActivitySupport" ) );
    }

    /**
      Set Enable JavaScript
    */
    static
    void setEnableJavascript( bool v )
    {
      if (!self()->isEnableJavascriptImmutable())
        self()->mEnableJavascript = v;
    }

    /**
      Get Enable JavaScript
    */
    static
    bool enableJavascript()
    {
      return self()->mEnableJavascript;
    }

    /**
      Is Enable JavaScript Immutable
    */
    static
    bool isEnableJavascriptImmutable()
    {
      return self()->isImmutable( QStringLiteral( "EnableJavascript" ) );
    }

    /**
      Set Always show the tab bar
    */
    static
    void setAlwaysShowTabBar( bool v )
    {
      if (!self()->isAlwaysShowTabBarImmutable())
        self()->mAlwaysShowTabBar = v;
    }

    /**
      Get Always show the tab bar
    */
    static
    bool alwaysShowTabBar()
    {
      return self()->mAlwaysShowTabBar;
    }

    /**
      Is Always show the tab bar Immutable
    */
    static
    bool isAlwaysShowTabBarImmutable()
    {
      return self()->isImmutable( QStringLiteral( "AlwaysShowTabBar" ) );
    }

    /**
      Set Show close buttons on tabs
    */
    static
    void setCloseButtonOnTabs( bool v )
    {
      if (!self()->isCloseButtonOnTabsImmutable())
        self()->mCloseButtonOnTabs = v;
    }

    /**
      Get Show close buttons on tabs
    */
    static
    bool closeButtonOnTabs()
    {
      return self()->mCloseButtonOnTabs;
    }

    /**
      Is Show close buttons on tabs Immutable
    */
    static
    bool isCloseButtonOnTabsImmutable()
    {
      return self()->isImmutable( QStringLiteral( "CloseButtonOnTabs" ) );
    }

    /**
      Set Open links in new tab instead of in new window
    */
    static
    void setNewWindowInTab( bool v )
    {
      if (!self()->isNewWindowInTabImmutable())
        self()->mNewWindowInTab = v;
    }

    /**
      Get Open links in new tab instead of in new window
    */
    static
    bool newWindowInTab()
    {
      return self()->mNewWindowInTab;
    }

    /**
      Is Open links in new tab instead of in new window Immutable
    */
    static
    bool isNewWindowInTabImmutable()
    {
      return self()->isImmutable( QStringLiteral( "NewWindowInTab" ) );
    }

    /**
      Set Use default KDE web browser
    */
    static
    void setExternalBrowserUseKdeDefault( bool v )
    {
      if (!self()->isExternalBrowserUseKdeDefaultImmutable())
        self()->mExternalBrowserUseKdeDefault = v;
    }

    /**
      Get Use default KDE web browser
    */
    static
    bool externalBrowserUseKdeDefault()
    {
      return self()->mExternalBrowserUseKdeDefault;
    }

    /**
      Is Use default KDE web browser Immutable
    */
    static
    bool isExternalBrowserUseKdeDefaultImmutable()
    {
      return self()->isImmutable( QStringLiteral( "ExternalBrowserUseKdeDefault" ) );
    }

    /**
      Set Use this command:
    */
    static
    void setExternalBrowserUseCustomCommand( bool v )
    {
      if (!self()->isExternalBrowserUseCustomCommandImmutable())
        self()->mExternalBrowserUseCustomCommand = v;
    }

    /**
      Get Use this command:
    */
    static
    bool externalBrowserUseCustomCommand()
    {
      return self()->mExternalBrowserUseCustomCommand;
    }

    /**
      Is Use this command: Immutable
    */
    static
    bool isExternalBrowserUseCustomCommandImmutable()
    {
      return self()->isImmutable( QStringLiteral( "ExternalBrowserUseCustomCommand" ) );
    }

    /**
      Set External Browser Custom Command
    */
    static
    void setExternalBrowserCustomCommand( const QString & v )
    {
      if (!self()->isExternalBrowserCustomCommandImmutable())
        self()->mExternalBrowserCustomCommand = v;
    }

    /**
      Get External Browser Custom Command
    */
    static
    QString externalBrowserCustomCommand()
    {
      return self()->mExternalBrowserCustomCommand;
    }

    /**
      Is External Browser Custom Command Immutable
    */
    static
    bool isExternalBrowserCustomCommandImmutable()
    {
      return self()->isImmutable( QStringLiteral( "ExternalBrowserCustomCommand" ) );
    }

    /**
      Set LMB Behaviour
    */
    static
    void setLMBBehaviour( int v )
    {
      if (!self()->isLMBBehaviourImmutable())
        self()->mLMBBehaviour = v;
    }

    /**
      Get LMB Behaviour
    */
    static
    int lMBBehaviour()
    {
      return self()->mLMBBehaviour;
    }

    /**
      Is LMB Behaviour Immutable
    */
    static
    bool isLMBBehaviourImmutable()
    {
      return self()->isImmutable( QStringLiteral( "LMBBehaviour" ) );
    }

    /**
      Set MMB Behaviour
    */
    static
    void setMMBBehaviour( int v )
    {
      if (!self()->isMMBBehaviourImmutable())
        self()->mMMBBehaviour = v;
    }

    /**
      Get MMB Behaviour
    */
    static
    int mMBBehaviour()
    {
      return self()->mMMBBehaviour;
    }

    /**
      Is MMB Behaviour Immutable
    */
    static
    bool isMMBBehaviourImmutable()
    {
      return self()->isImmutable( QStringLiteral( "MMBBehaviour" ) );
    }

    /**
      Set Feedlist Header States
    */
    static
    void setFeedlistHeaderStates( const QList<int> & v )
    {
      if (!self()->isFeedlistHeaderStatesImmutable())
        self()->mFeedlistHeaderStates = v;
    }

    /**
      Get Feedlist Header States
    */
    static
    QList<int> feedlistHeaderStates()
    {
      return self()->mFeedlistHeaderStates;
    }

    /**
      Is Feedlist Header States Immutable
    */
    static
    bool isFeedlistHeaderStatesImmutable()
    {
      return self()->isImmutable( QStringLiteral( "FeedlistHeaderStates" ) );
    }

    /**
      Set Articlelist Header States
    */
    static
    void setArticlelistHeaderStates( const QList<int> & v )
    {
      if (!self()->isArticlelistHeaderStatesImmutable())
        self()->mArticlelistHeaderStates = v;
    }

    /**
      Get Articlelist Header States
    */
    static
    QList<int> articlelistHeaderStates()
    {
      return self()->mArticlelistHeaderStates;
    }

    /**
      Is Articlelist Header States Immutable
    */
    static
    bool isArticlelistHeaderStatesImmutable()
    {
      return self()->isImmutable( QStringLiteral( "ArticlelistHeaderStates" ) );
    }

    /**
      Set Articlelist Sort Column
    */
    static
    void setArticlelistSortColumn( int v )
    {
      if (!self()->isArticlelistSortColumnImmutable())
        self()->mArticlelistSortColumn = v;
    }

    /**
      Get Articlelist Sort Column
    */
    static
    int articlelistSortColumn()
    {
      return self()->mArticlelistSortColumn;
    }

    /**
      Is Articlelist Sort Column Immutable
    */
    static
    bool isArticlelistSortColumnImmutable()
    {
      return self()->isImmutable( QStringLiteral( "ArticlelistSortColumn" ) );
    }

    /**
      Set Articlelist Sort Order
    */
    static
    void setArticlelistSortOrder( int v )
    {
      if (!self()->isArticlelistSortOrderImmutable())
        self()->mArticlelistSortOrder = v;
    }

    /**
      Get Articlelist Sort Order
    */
    static
    int articlelistSortOrder()
    {
      return self()->mArticlelistSortOrder;
    }

    /**
      Is Articlelist Sort Order Immutable
    */
    static
    bool isArticlelistSortOrderImmutable()
    {
      return self()->isImmutable( QStringLiteral( "ArticlelistSortOrder" ) );
    }

    /**
      Set Archive Backend
    */
    static
    void setArchiveBackend( const QString & v )
    {
      if (!self()->isArchiveBackendImmutable())
        self()->mArchiveBackend = v;
    }

    /**
      Get Archive Backend
    */
    static
    QString archiveBackend()
    {
      return self()->mArchiveBackend;
    }

    /**
      Is Archive Backend Immutable
    */
    static
    bool isArchiveBackendImmutable()
    {
      return self()->isImmutable( QStringLiteral( "ArchiveBackend" ) );
    }

    /**
      Set Delay Mark Read
    */
    static
    void setUseMarkReadDelay( bool v )
    {
      if (!self()->isUseMarkReadDelayImmutable())
        self()->mUseMarkReadDelay = v;
    }

    /**
      Get Delay Mark Read
    */
    static
    bool useMarkReadDelay()
    {
      return self()->mUseMarkReadDelay;
    }

    /**
      Is Delay Mark Read Immutable
    */
    static
    bool isUseMarkReadDelayImmutable()
    {
      return self()->isImmutable( QStringLiteral( "UseMarkReadDelay" ) );
    }

    /**
      Set Mark Read Delay
    */
    static
    void setMarkReadDelay( int v )
    {
      if (!self()->isMarkReadDelayImmutable())
        self()->mMarkReadDelay = v;
    }

    /**
      Get Mark Read Delay
    */
    static
    int markReadDelay()
    {
      return self()->mMarkReadDelay;
    }

    /**
      Is Mark Read Delay Immutable
    */
    static
    bool isMarkReadDelayImmutable()
    {
      return self()->isImmutable( QStringLiteral( "MarkReadDelay" ) );
    }

    /**
      Set Reset Quick Filter On Node Change
    */
    static
    void setResetQuickFilterOnNodeChange( bool v )
    {
      if (!self()->isResetQuickFilterOnNodeChangeImmutable())
        self()->mResetQuickFilterOnNodeChange = v;
    }

    /**
      Get Reset Quick Filter On Node Change
    */
    static
    bool resetQuickFilterOnNodeChange()
    {
      return self()->mResetQuickFilterOnNodeChange;
    }

    /**
      Is Reset Quick Filter On Node Change Immutable
    */
    static
    bool isResetQuickFilterOnNodeChangeImmutable()
    {
      return self()->isImmutable( QStringLiteral( "ResetQuickFilterOnNodeChange" ) );
    }

  protected:
    Settings();
    friend class SettingsHelper;


    // View
    bool mHideReadFeeds;
    bool mShowMenuBar;
    bool mLockFeedsInPlace;
    bool mAutoExpandFolders;
    bool mShowQuickFilter;
    int mStatusFilter;
    QString mTextFilter;
    int mViewMode;
    QList<int> mSplitter1Sizes;
    QList<int> mSplitter2Sizes;

    // Security
    bool mCheckPhishingUrl;
    bool mLoadExternalReferences;

    // Appearance
    QString mStandardFont;
    QString mFixedFont;
    QString mSerifFont;
    QString mSansSerifFont;
    bool mUseCustomColors;
    QColor mColorUnreadArticles;
    QColor mColorNewArticles;

    // HTML Settings
    QStringList mFonts;
    int mMediumFontSize;
    int mMinimumFontSize;
    bool mAccessKeyEnabled;

    // Archive
    int mArchiveMode;
    int mMaxArticleAge;
    int mMaxArticleNumber;
    bool mDoNotExpireImportantArticles;

    // Network
    int mConcurrentFetches;
    bool mUseHTMLCache;
    QString mCustomUserAgent;

    // General
    bool mFetchOnStartup;
    bool mMarkAllFeedsReadOnStartup;
    bool mUseIntervalFetch;
    int mAutoFetchInterval;
    bool mUseNotifications;
    bool mShowTrayIcon;
    bool mShowUnreadInTaskbar;
    bool mDisableIntroduction;
    bool mDisableSaveAsNotification;
    QString mPreviousNewFeaturesMD5;
    bool mPlasmaActivitySupport;

    // Browser
    bool mEnableJavascript;
    bool mAlwaysShowTabBar;
    bool mCloseButtonOnTabs;
    bool mNewWindowInTab;
    bool mExternalBrowserUseKdeDefault;
    bool mExternalBrowserUseCustomCommand;
    QString mExternalBrowserCustomCommand;
    int mLMBBehaviour;
    int mMMBBehaviour;

    // Columns
    QList<int> mFeedlistHeaderStates;
    QList<int> mArticlelistHeaderStates;
    int mArticlelistSortColumn;
    int mArticlelistSortOrder;

    // Advanced
    QString mArchiveBackend;
    bool mUseMarkReadDelay;
    int mMarkReadDelay;
    bool mResetQuickFilterOnNodeChange;
};

}

#endif

