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

#include <konqsettingsbase.h>
#include <libkonqsettings_export.h>

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

namespace Konq {

class LIBKONQSETTINGS_EXPORT Settings : public Konq::SettingsBase
{
  public:

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

    /**
      Set Start Page
    */
    static
    void setStartURL( const QString & v )
    {
      if (!self()->isStartURLImmutable())
        self()->mStartURL = v;
    }

    /**
      Get Start Page
    */
    static
    QString startURL()
    {
      return self()->mStartURL;
    }

    /**
      Is Start Page Immutable
    */
    static
    bool isStartURLImmutable()
    {
      return self()->isImmutable( QStringLiteral( "StartURL" ) );
    }

    /**
      Set Home Page
    */
    static
    void setHomeURL( const QString & v )
    {
      if (!self()->isHomeURLImmutable())
        self()->mHomeURL = v;
    }

    /**
      Get Home Page
    */
    static
    QString homeURL()
    {
      return self()->mHomeURL;
    }

    /**
      Is Home Page Immutable
    */
    static
    bool isHomeURLImmutable()
    {
      return self()->isImmutable( QStringLiteral( "HomeURL" ) );
    }

    /**
      Set AlwaysDuplicatePageWhenSplittingView
    */
    static
    void setAlwaysDuplicatePageWhenSplittingView( bool v )
    {
      if (!self()->isAlwaysDuplicatePageWhenSplittingViewImmutable())
        self()->mAlwaysDuplicatePageWhenSplittingView = v;
    }

    /**
      Get AlwaysDuplicatePageWhenSplittingView
    */
    static
    bool alwaysDuplicatePageWhenSplittingView()
    {
      return self()->mAlwaysDuplicatePageWhenSplittingView;
    }

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

    /**
      Set RestoreLastState
    */
    static
    void setRestoreLastState( bool v )
    {
      if (!self()->isRestoreLastStateImmutable())
        self()->mRestoreLastState = v;
    }

    /**
      Get RestoreLastState
    */
    static
    bool restoreLastState()
    {
      return self()->mRestoreLastState;
    }

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

    /**
      Set Maximum number of Closed Items
    */
    static
    void setMaxNumClosedItems( int v )
    {
      if (v < 0)
      {
        qDebug() << "setMaxNumClosedItems: value " << v << " is less than the minimum value of 0";
        v = 0;
      }
      if (!self()->isMaxNumClosedItemsImmutable())
        self()->mMaxNumClosedItems = v;
    }

    /**
      Get Maximum number of Closed Items
    */
    static
    int maxNumClosedItems()
    {
      return self()->mMaxNumClosedItems;
    }

    /**
      Is Maximum number of Closed Items Immutable
    */
    static
    bool isMaxNumClosedItemsImmutable()
    {
      return self()->isImmutable( QStringLiteral( "maxNumClosedItems" ) );
    }

    /**
      Set Open folders in separate windows
    */
    static
    void setAlwaysNewWin( bool v )
    {
      if (!self()->isAlwaysNewWinImmutable())
        self()->mAlwaysNewWin = v;
    }

    /**
      Get Open folders in separate windows
    */
    static
    bool alwaysNewWin()
    {
      return self()->mAlwaysNewWin;
    }

    /**
      Is Open folders in separate windows Immutable
    */
    static
    bool isAlwaysNewWinImmutable()
    {
      return self()->isImmutable( QStringLiteral( "AlwaysNewWin" ) );
    }

    /**
      Set Show file tips
    */
    static
    void setShowFileTips( bool v )
    {
      if (!self()->isShowFileTipsImmutable())
        self()->mShowFileTips = v;
    }

    /**
      Get Show file tips
    */
    static
    bool showFileTips()
    {
      return self()->mShowFileTips;
    }

    /**
      Is Show file tips Immutable
    */
    static
    bool isShowFileTipsImmutable()
    {
      return self()->isImmutable( QStringLiteral( "ShowFileTips" ) );
    }

    /**
      Set FileTipsItems
    */
    static
    void setFileTipsItems( int v )
    {
      if (!self()->isFileTipsItemsImmutable())
        self()->mFileTipsItems = v;
    }

    /**
      Get FileTipsItems
    */
    static
    int fileTipsItems()
    {
      return self()->mFileTipsItems;
    }

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

    /**
      Set Show previews in file tips
    */
    static
    void setShowPreviewsInFileTips( bool v )
    {
      if (!self()->isShowPreviewsInFileTipsImmutable())
        self()->mShowPreviewsInFileTips = v;
    }

    /**
      Get Show previews in file tips
    */
    static
    bool showPreviewsInFileTips()
    {
      return self()->mShowPreviewsInFileTips;
    }

    /**
      Is Show previews in file tips Immutable
    */
    static
    bool isShowPreviewsInFileTipsImmutable()
    {
      return self()->isImmutable( QStringLiteral( "ShowPreviewsInFileTips" ) );
    }

    /**
      Set Show 'Delete' menu entries which bypass the trashcan
    */
    static
    void setShowDeleteCommand( bool v )
    {
      if (!self()->isShowDeleteCommandImmutable())
        self()->mShowDeleteCommand = v;
    }

    /**
      Get Show 'Delete' menu entries which bypass the trashcan
    */
    static
    bool showDeleteCommand()
    {
      return self()->mShowDeleteCommand;
    }

    /**
      Is Show 'Delete' menu entries which bypass the trashcan Immutable
    */
    static
    bool isShowDeleteCommandImmutable()
    {
      return self()->isImmutable( QStringLiteral( "ShowDeleteCommand" ) );
    }

    /**
      Set MMBOpensTab
    */
    static
    void setMmbOpensTab( bool v )
    {
      if (!self()->isMmbOpensTabImmutable())
        self()->mMmbOpensTab = v;
    }

    /**
      Get MMBOpensTab
    */
    static
    bool mmbOpensTab()
    {
      return self()->mMmbOpensTab;
    }

    /**
      Is MMBOpensTab Immutable
    */
    static
    bool isMmbOpensTabImmutable()
    {
      return self()->isImmutable( QStringLiteral( "MmbOpensTab" ) );
    }

    /**
      Set AlwaysTabbedMode
    */
    static
    void setAlwaysTabbedMode( bool v )
    {
      if (!self()->isAlwaysTabbedModeImmutable())
        self()->mAlwaysTabbedMode = v;
    }

    /**
      Get AlwaysTabbedMode
    */
    static
    bool alwaysTabbedMode()
    {
      return self()->mAlwaysTabbedMode;
    }

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

    /**
      Set NewTabsInFront
    */
    static
    void setNewTabsInFront( bool v )
    {
      if (!self()->isNewTabsInFrontImmutable())
        self()->mNewTabsInFront = v;
    }

    /**
      Get NewTabsInFront
    */
    static
    bool newTabsInFront()
    {
      return self()->mNewTabsInFront;
    }

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

    /**
      Set OpenAfterCurrentPage
    */
    static
    void setOpenAfterCurrentPage( bool v )
    {
      if (!self()->isOpenAfterCurrentPageImmutable())
        self()->mOpenAfterCurrentPage = v;
    }

    /**
      Get OpenAfterCurrentPage
    */
    static
    bool openAfterCurrentPage()
    {
      return self()->mOpenAfterCurrentPage;
    }

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

    /**
      Set PermanentCloseButton
    */
    static
    void setPermanentCloseButton( bool v )
    {
      if (!self()->isPermanentCloseButtonImmutable())
        self()->mPermanentCloseButton = v;
    }

    /**
      Get PermanentCloseButton
    */
    static
    bool permanentCloseButton()
    {
      return self()->mPermanentCloseButton;
    }

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

    /**
      Set KonquerorTabforExternalURL
    */
    static
    void setKonquerorTabforExternalURL( bool v )
    {
      if (!self()->isKonquerorTabforExternalURLImmutable())
        self()->mKonquerorTabforExternalURL = v;
    }

    /**
      Get KonquerorTabforExternalURL
    */
    static
    bool konquerorTabforExternalURL()
    {
      return self()->mKonquerorTabforExternalURL;
    }

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

    /**
      Set PopupsWithinTabs
    */
    static
    void setPopupsWithinTabs( bool v )
    {
      if (!self()->isPopupsWithinTabsImmutable())
        self()->mPopupsWithinTabs = v;
    }

    /**
      Get PopupsWithinTabs
    */
    static
    bool popupsWithinTabs()
    {
      return self()->mPopupsWithinTabs;
    }

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

    /**
      Set TabCloseActivatePrevious
    */
    static
    void setTabCloseActivatePrevious( bool v )
    {
      if (!self()->isTabCloseActivatePreviousImmutable())
        self()->mTabCloseActivatePrevious = v;
    }

    /**
      Get TabCloseActivatePrevious
    */
    static
    bool tabCloseActivatePrevious()
    {
      return self()->mTabCloseActivatePrevious;
    }

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

    /**
      Set MouseMiddleClickClosesTab
    */
    static
    void setMouseMiddleClickClosesTab( bool v )
    {
      if (!self()->isMouseMiddleClickClosesTabImmutable())
        self()->mMouseMiddleClickClosesTab = v;
    }

    /**
      Get MouseMiddleClickClosesTab
    */
    static
    bool mouseMiddleClickClosesTab()
    {
      return self()->mMouseMiddleClickClosesTab;
    }

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

    /**
      Set AddTabButton
    */
    static
    void setAddTabButton( bool v )
    {
      if (!self()->isAddTabButtonImmutable())
        self()->mAddTabButton = v;
    }

    /**
      Get AddTabButton
    */
    static
    bool addTabButton()
    {
      return self()->mAddTabButton;
    }

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

    /**
      Set CloseTabButton
    */
    static
    void setCloseTabButton( bool v )
    {
      if (!self()->isCloseTabButtonImmutable())
        self()->mCloseTabButton = v;
    }

    /**
      Get CloseTabButton
    */
    static
    bool closeTabButton()
    {
      return self()->mCloseTabButton;
    }

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

    /**
      Set MaximumTabLength
    */
    static
    void setMaximumTabLength( int v )
    {
      if (!self()->isMaximumTabLengthImmutable())
        self()->mMaximumTabLength = v;
    }

    /**
      Get MaximumTabLength
    */
    static
    int maximumTabLength()
    {
      return self()->mMaximumTabLength;
    }

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

    /**
      Set MinimumTabLength
    */
    static
    void setMinimumTabLength( int v )
    {
      if (!self()->isMinimumTabLengthImmutable())
        self()->mMinimumTabLength = v;
    }

    /**
      Get MinimumTabLength
    */
    static
    int minimumTabLength()
    {
      return self()->mMinimumTabLength;
    }

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

    /**
      Set TabBarPosition
    */
    static
    void setTabBarPosition( int v )
    {
      if (!self()->isTabBarPositionImmutable())
        self()->mTabBarPosition = v;
    }

    /**
      Get TabBarPosition
    */
    static
    int tabBarPosition()
    {
      return self()->mTabBarPosition;
    }

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

    /**
      Set Number of Open With items in the File menu
    */
    static
    void setOpenWithItems( int v )
    {
      if (!self()->isOpenWithItemsImmutable())
        self()->mOpenWithItems = v;
    }

    /**
      Get Number of Open With items in the File menu
    */
    static
    int openWithItems()
    {
      return self()->mOpenWithItems;
    }

    /**
      Is Number of Open With items in the File menu Immutable
    */
    static
    bool isOpenWithItemsImmutable()
    {
      return self()->isImmutable( QStringLiteral( "OpenWithItems" ) );
    }

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

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

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

    /**
      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 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 DefaultEncoding
    */
    static
    void setDefaultEncoding( const QString & v )
    {
      if (!self()->isDefaultEncodingImmutable())
        self()->mDefaultEncoding = v;
    }

    /**
      Get DefaultEncoding
    */
    static
    QString defaultEncoding()
    {
      return self()->mDefaultEncoding;
    }

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

    /**
      Set UnderlineLinks
    */
    static
    void setHtmlUnderlineLinks( bool v )
    {
      if (!self()->isHtmlUnderlineLinksImmutable())
        self()->mHtmlUnderlineLinks = v;
    }

    /**
      Get UnderlineLinks
    */
    static
    bool htmlUnderlineLinks()
    {
      return self()->mHtmlUnderlineLinks;
    }

    /**
      Is UnderlineLinks Immutable
    */
    static
    bool isHtmlUnderlineLinksImmutable()
    {
      return self()->isImmutable( QStringLiteral( "HtmlUnderlineLinks" ) );
    }

    /**
      Set HoverLinks
    */
    static
    void setHoverLinks( bool v )
    {
      if (!self()->isHoverLinksImmutable())
        self()->mHoverLinks = v;
    }

    /**
      Get HoverLinks
    */
    static
    bool hoverLinks()
    {
      return self()->mHoverLinks;
    }

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

    /**
      Set AutoLoadImages
    */
    static
    void setAutoLoadImages( bool v )
    {
      if (!self()->isAutoLoadImagesImmutable())
        self()->mAutoLoadImages = v;
    }

    /**
      Get AutoLoadImages
    */
    static
    bool autoLoadImages()
    {
      return self()->mAutoLoadImages;
    }

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

    /**
      Set ShowAnimations
    */
    static
    void setShowAnimations( const QString & v )
    {
      if (!self()->isShowAnimationsImmutable())
        self()->mShowAnimations = v;
    }

    /**
      Get ShowAnimations
    */
    static
    QString showAnimations()
    {
      return self()->mShowAnimations;
    }

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

    /**
      Set FormCompletion
    */
    static
    void setFormCompletion( bool v )
    {
      if (!self()->isFormCompletionImmutable())
        self()->mFormCompletion = v;
    }

    /**
      Get FormCompletion
    */
    static
    bool formCompletion()
    {
      return self()->mFormCompletion;
    }

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

    /**
      Set MaxFormCompletionItems
    */
    static
    void setMaxFormCompletionItems( int v )
    {
      if (!self()->isMaxFormCompletionItemsImmutable())
        self()->mMaxFormCompletionItems = v;
    }

    /**
      Get MaxFormCompletionItems
    */
    static
    int maxFormCompletionItems()
    {
      return self()->mMaxFormCompletionItems;
    }

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

    /**
      Set InternalPdfViewer
    */
    static
    void setUseInternalPDFViewer( bool v )
    {
      if (!self()->isUseInternalPDFViewerImmutable())
        self()->mUseInternalPDFViewer = v;
    }

    /**
      Get InternalPdfViewer
    */
    static
    bool useInternalPDFViewer()
    {
      return self()->mUseInternalPDFViewer;
    }

    /**
      Is InternalPdfViewer Immutable
    */
    static
    bool isUseInternalPDFViewerImmutable()
    {
      return self()->isImmutable( QStringLiteral( "useInternalPDFViewer" ) );
    }

    /**
      Set AlwaysEmbedInNewTab
    */
    static
    void setAlwaysEmbedInNewTab( bool v )
    {
      if (!self()->isAlwaysEmbedInNewTabImmutable())
        self()->mAlwaysEmbedInNewTab = v;
    }

    /**
      Get AlwaysEmbedInNewTab
    */
    static
    bool alwaysEmbedInNewTab()
    {
      return self()->mAlwaysEmbedInNewTab;
    }

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

    /**
      Set EnableFavicon
    */
    static
    void setEnableFavicon( bool v )
    {
      if (!self()->isEnableFaviconImmutable())
        self()->mEnableFavicon = v;
    }

    /**
      Get EnableFavicon
    */
    static
    bool enableFavicon()
    {
      return self()->mEnableFavicon;
    }

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

    /**
      Set AutomaticDetectionLanguage
    */
    static
    void setAutomaticDetectionLanguage( int v )
    {
      if (!self()->isAutomaticDetectionLanguageImmutable())
        self()->mAutomaticDetectionLanguage = v;
    }

    /**
      Get AutomaticDetectionLanguage
    */
    static
    int automaticDetectionLanguage()
    {
      return self()->mAutomaticDetectionLanguage;
    }

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

    /**
      Set EnforceDefaultCharset
    */
    static
    void setEnforceDefaultCharset( bool v )
    {
      if (!self()->isEnforceDefaultCharsetImmutable())
        self()->mEnforceDefaultCharset = v;
    }

    /**
      Get EnforceDefaultCharset
    */
    static
    bool enforceDefaultCharset()
    {
      return self()->mEnforceDefaultCharset;
    }

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

    /**
      Set UserStyleSheetEnabled
    */
    static
    void setUserStyleSheetEnabled( bool v )
    {
      if (!self()->isUserStyleSheetEnabledImmutable())
        self()->mUserStyleSheetEnabled = v;
    }

    /**
      Get UserStyleSheetEnabled
    */
    static
    bool userStyleSheetEnabled()
    {
      return self()->mUserStyleSheetEnabled;
    }

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

    /**
      Set OpenMiddleClick
    */
    static
    void setOpenMiddleClick( bool v )
    {
      if (!self()->isOpenMiddleClickImmutable())
        self()->mOpenMiddleClick = v;
    }

    /**
      Get OpenMiddleClick
    */
    static
    bool openMiddleClick()
    {
      return self()->mOpenMiddleClick;
    }

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

    /**
      Set BackRightClick
    */
    static
    void setBackRightClick( bool v )
    {
      if (!self()->isBackRightClickImmutable())
        self()->mBackRightClick = v;
    }

    /**
      Get BackRightClick
    */
    static
    bool backRightClick()
    {
      return self()->mBackRightClick;
    }

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

    /**
      Set OfferToSaveWebsitePassword
    */
    static
    void setOfferToSaveWebsitePassword( bool v )
    {
      if (!self()->isOfferToSaveWebsitePasswordImmutable())
        self()->mOfferToSaveWebsitePassword = v;
    }

    /**
      Get OfferToSaveWebsitePassword
    */
    static
    bool offerToSaveWebsitePassword()
    {
      return self()->mOfferToSaveWebsitePassword;
    }

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

    /**
      Set ToggableViewsShown
    */
    static
    void setToggableViewsShown( const QStringList & v )
    {
      if (!self()->isToggableViewsShownImmutable())
        self()->mToggableViewsShown = v;
    }

    /**
      Get ToggableViewsShown
    */
    static
    QStringList toggableViewsShown()
    {
      return self()->mToggableViewsShown;
    }

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

    /**
      Set OpenGroups
    */
    static
    void setOpenGroups( const QString & v )
    {
      if (!self()->isOpenGroupsImmutable())
        self()->mOpenGroups = v;
    }

    /**
      Get OpenGroups
    */
    static
    QString openGroups()
    {
      return self()->mOpenGroups;
    }

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

    /**
      Set Maximum number of history items per view
    */
    static
    void setMaximumHistoryEntriesPerView( int v )
    {
      if (!self()->isMaximumHistoryEntriesPerViewImmutable())
        self()->mMaximumHistoryEntriesPerView = v;
    }

    /**
      Get Maximum number of history items per view
    */
    static
    int maximumHistoryEntriesPerView()
    {
      return self()->mMaximumHistoryEntriesPerView;
    }

    /**
      Is Maximum number of history items per view Immutable
    */
    static
    bool isMaximumHistoryEntriesPerViewImmutable()
    {
      return self()->isImmutable( QStringLiteral( "MaximumHistoryEntriesPerView" ) );
    }

    /**
      Set Default Action
    */
    static
    void setDefaultAction( int v )
    {
      if (!self()->isDefaultActionImmutable())
        self()->mDefaultAction = v;
    }

    /**
      Get Default Action
    */
    static
    int defaultAction()
    {
      return self()->mDefaultAction;
    }

    /**
      Is Default Action Immutable
    */
    static
    bool isDefaultActionImmutable()
    {
      return self()->isImmutable( QStringLiteral( "defaultAction" ) );
    }

    /**
      Set Maximum age of History entries
    */
    static
    void setMaximumHistoryEntryAge( int v )
    {
      if (!self()->isMaximumHistoryEntryAgeImmutable())
        self()->mMaximumHistoryEntryAge = v;
    }

    /**
      Get Maximum age of History entries
    */
    static
    int maximumHistoryEntryAge()
    {
      return self()->mMaximumHistoryEntryAge;
    }

    /**
      Is Maximum age of History entries Immutable
    */
    static
    bool isMaximumHistoryEntryAgeImmutable()
    {
      return self()->isImmutable( QStringLiteral( "maximumHistoryEntryAge" ) );
    }

    /**
      Set ECMADomains
    */
    static
    void setEcmaDomains( const QStringList & v )
    {
      if (!self()->isEcmaDomainsImmutable())
        self()->mEcmaDomains = v;
    }

    /**
      Get ECMADomains
    */
    static
    QStringList ecmaDomains()
    {
      return self()->mEcmaDomains;
    }

    /**
      Is ECMADomains Immutable
    */
    static
    bool isEcmaDomainsImmutable()
    {
      return self()->isImmutable( QStringLiteral( "ecmaDomains" ) );
    }

    /**
      Set ECMADomainSettings
    */
    static
    void setECMADomainSettings( const QStringList & v )
    {
      if (!self()->isECMADomainSettingsImmutable())
        self()->mECMADomainSettings = v;
    }

    /**
      Get ECMADomainSettings
    */
    static
    QStringList eCMADomainSettings()
    {
      return self()->mECMADomainSettings;
    }

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

    /**
      Set EnableJavaScript
    */
    static
    void setEnableJavaScript( bool v )
    {
      if (!self()->isEnableJavaScriptImmutable())
        self()->mEnableJavaScript = v;
    }

    /**
      Get EnableJavaScript
    */
    static
    bool enableJavaScript()
    {
      return self()->mEnableJavaScript;
    }

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

    /**
      Set WindowOpenPolicy
    */
    static
    void setWindowOpenPolicy( uint v )
    {
      if (!self()->isWindowOpenPolicyImmutable())
        self()->mWindowOpenPolicy = v;
    }

    /**
      Get WindowOpenPolicy
    */
    static
    uint windowOpenPolicy()
    {
      return self()->mWindowOpenPolicy;
    }

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

    /**
      Set WindowResizePolicy
    */
    static
    void setWindowResizePolicy( uint v )
    {
      if (!self()->isWindowResizePolicyImmutable())
        self()->mWindowResizePolicy = v;
    }

    /**
      Get WindowResizePolicy
    */
    static
    uint windowResizePolicy()
    {
      return self()->mWindowResizePolicy;
    }

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

    /**
      Set WindowMovePolicy
    */
    static
    void setWindowMovePolicy( uint v )
    {
      if (!self()->isWindowMovePolicyImmutable())
        self()->mWindowMovePolicy = v;
    }

    /**
      Get WindowMovePolicy
    */
    static
    uint windowMovePolicy()
    {
      return self()->mWindowMovePolicy;
    }

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

    /**
      Set WindowFocusPolicy
    */
    static
    void setWindowFocusPolicy( uint v )
    {
      if (!self()->isWindowFocusPolicyImmutable())
        self()->mWindowFocusPolicy = v;
    }

    /**
      Get WindowFocusPolicy
    */
    static
    uint windowFocusPolicy()
    {
      return self()->mWindowFocusPolicy;
    }

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

    /**
      Set WindowStatusPolicy
    */
    static
    void setWindowStatusPolicy( uint v )
    {
      if (!self()->isWindowStatusPolicyImmutable())
        self()->mWindowStatusPolicy = v;
    }

    /**
      Get WindowStatusPolicy
    */
    static
    uint windowStatusPolicy()
    {
      return self()->mWindowStatusPolicy;
    }

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

    /**
      Set EnablePlugins
    */
    static
    void setEnablePlugins( bool v )
    {
      if (!self()->isEnablePluginsImmutable())
        self()->mEnablePlugins = v;
    }

    /**
      Get EnablePlugins
    */
    static
    bool enablePlugins()
    {
      return self()->mEnablePlugins;
    }

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

    /**
      Set PluginDomains
    */
    static
    void setPluginDomains( const QStringList & v )
    {
      if (!self()->isPluginDomainsImmutable())
        self()->mPluginDomains = v;
    }

    /**
      Get PluginDomains
    */
    static
    QStringList pluginDomains()
    {
      return self()->mPluginDomains;
    }

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

    /**
      Set MultipleTabConfirm
    */
    static
    void setMultipleTabConfirm( bool v )
    {
      if (!self()->isMultipleTabConfirmImmutable())
        self()->mMultipleTabConfirm = v;
    }

    /**
      Get MultipleTabConfirm
    */
    static
    bool multipleTabConfirm()
    {
      return self()->mMultipleTabConfirm;
    }

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

    /**
      Set plugin-application/x-shockwave-flash
    */
    static
    void setPlugin_application_x_shockwave_flash( const QString & v )
    {
      if (!self()->isPlugin_application_x_shockwave_flashImmutable())
        self()->mPlugin_application_x_shockwave_flash = v;
    }

    /**
      Get plugin-application/x-shockwave-flash
    */
    static
    QString plugin_application_x_shockwave_flash()
    {
      return self()->mPlugin_application_x_shockwave_flash;
    }

    /**
      Is plugin-application/x-shockwave-flash Immutable
    */
    static
    bool isPlugin_application_x_shockwave_flashImmutable()
    {
      return self()->isImmutable( QStringLiteral( "plugin_application_x_shockwave_flash" ) );
    }

    /**
      Set plugin-image/svg+xml
    */
    static
    void setPlugin_image_svg_xml( const QString & v )
    {
      if (!self()->isPlugin_image_svg_xmlImmutable())
        self()->mPlugin_image_svg_xml = v;
    }

    /**
      Get plugin-image/svg+xml
    */
    static
    QString plugin_image_svg_xml()
    {
      return self()->mPlugin_image_svg_xml;
    }

    /**
      Is plugin-image/svg+xml Immutable
    */
    static
    bool isPlugin_image_svg_xmlImmutable()
    {
      return self()->isImmutable( QStringLiteral( "plugin_image_svg_xml" ) );
    }

    /**
      Set AlwaysHavePreloaded
    */
    static
    void setAlwaysHavePreloaded( bool v )
    {
      if (!self()->isAlwaysHavePreloadedImmutable())
        self()->mAlwaysHavePreloaded = v;
    }

    /**
      Get AlwaysHavePreloaded
    */
    static
    bool alwaysHavePreloaded()
    {
      return self()->mAlwaysHavePreloaded;
    }

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

    /**
      Set PreloadOnStartup
    */
    static
    void setPreloadOnStartup( bool v )
    {
      if (!self()->isPreloadOnStartupImmutable())
        self()->mPreloadOnStartup = v;
    }

    /**
      Get PreloadOnStartup
    */
    static
    bool preloadOnStartup()
    {
      return self()->mPreloadOnStartup;
    }

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

    /**
      Set BgImage
    */
    static
    void setBgImage( const QString & v )
    {
      if (!self()->isBgImageImmutable())
        self()->mBgImage = v;
    }

    /**
      Get BgImage
    */
    static
    QString bgImage()
    {
      return self()->mBgImage;
    }

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

    /**
      Set SaveURLInProfile
    */
    static
    void setSaveURLInProfile( bool v )
    {
      if (!self()->isSaveURLInProfileImmutable())
        self()->mSaveURLInProfile = v;
    }

    /**
      Get SaveURLInProfile
    */
    static
    bool saveURLInProfile()
    {
      return self()->mSaveURLInProfile;
    }

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

    /**
      Set CompletionMode
    */
    static
    void setSettingsCompletionMode( int v )
    {
      if (!self()->isSettingsCompletionModeImmutable())
        self()->mSettingsCompletionMode = v;
    }

    /**
      Get CompletionMode
    */
    static
    int settingsCompletionMode()
    {
      return self()->mSettingsCompletionMode;
    }

    /**
      Is CompletionMode Immutable
    */
    static
    bool isSettingsCompletionModeImmutable()
    {
      return self()->isImmutable( QStringLiteral( "SettingsCompletionMode" ) );
    }

    /**
      Set Number of most visited URLs
    */
    static
    void setNumberofmostvisitedURLs( int v )
    {
      if (!self()->isNumberofmostvisitedURLsImmutable())
        self()->mNumberofmostvisitedURLs = v;
    }

    /**
      Get Number of most visited URLs
    */
    static
    int numberofmostvisitedURLs()
    {
      return self()->mNumberofmostvisitedURLs;
    }

    /**
      Is Number of most visited URLs Immutable
    */
    static
    bool isNumberofmostvisitedURLsImmutable()
    {
      return self()->isImmutable( QStringLiteral( "NumberofmostvisitedURLs" ) );
    }

    /**
      Set Ask confirmation for deleting a file.
    */
    static
    void setConfirmDelete( bool v )
    {
      if (!self()->isConfirmDeleteImmutable())
        self()->mConfirmDelete = v;
    }

    /**
      Get Ask confirmation for deleting a file.
    */
    static
    bool confirmDelete()
    {
      return self()->mConfirmDelete;
    }

    /**
      Is Ask confirmation for deleting a file. Immutable
    */
    static
    bool isConfirmDeleteImmutable()
    {
      return self()->isImmutable( QStringLiteral( "ConfirmDelete" ) );
    }

    /**
      Set Ask confirmation for move to trash
    */
    static
    void setConfirmTrash( bool v )
    {
      if (!self()->isConfirmTrashImmutable())
        self()->mConfirmTrash = v;
    }

    /**
      Get Ask confirmation for move to trash
    */
    static
    bool confirmTrash()
    {
      return self()->mConfirmTrash;
    }

    /**
      Is Ask confirmation for move to trash Immutable
    */
    static
    bool isConfirmTrashImmutable()
    {
      return self()->isImmutable( QStringLiteral( "ConfirmTrash" ) );
    }

    /**
      Set Open tabs inside current window
    */
    static
    void setOpenTabsInsideCurrentWindow( bool v )
    {
      if (!self()->isOpenTabsInsideCurrentWindowImmutable())
        self()->mOpenTabsInsideCurrentWindow = v;
    }

    /**
      Get Open tabs inside current window
    */
    static
    bool openTabsInsideCurrentWindow()
    {
      return self()->mOpenTabsInsideCurrentWindow;
    }

    /**
      Is Open tabs inside current window Immutable
    */
    static
    bool isOpenTabsInsideCurrentWindowImmutable()
    {
      return self()->isImmutable( QStringLiteral( "OpenTabsInsideCurrentWindow" ) );
    }

    /**
      Set AutoSaveInterval
    */
    static
    void setAutoSaveInterval( int v )
    {
      if (!self()->isAutoSaveIntervalImmutable())
        self()->mAutoSaveInterval = v;
    }

    /**
      Get AutoSaveInterval
    */
    static
    int autoSaveInterval()
    {
      return self()->mAutoSaveInterval;
    }

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

    /**
      Set CacheEnabled
    */
    static
    void setCacheEnabled( bool v )
    {
      if (!self()->isCacheEnabledImmutable())
        self()->mCacheEnabled = v;
    }

    /**
      Get CacheEnabled
    */
    static
    bool cacheEnabled()
    {
      return self()->mCacheEnabled;
    }

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

    /**
      Set MemoryCache
    */
    static
    void setKeepCacheInMemory( bool v )
    {
      if (!self()->isKeepCacheInMemoryImmutable())
        self()->mKeepCacheInMemory = v;
    }

    /**
      Get MemoryCache
    */
    static
    bool keepCacheInMemory()
    {
      return self()->mKeepCacheInMemory;
    }

    /**
      Is MemoryCache Immutable
    */
    static
    bool isKeepCacheInMemoryImmutable()
    {
      return self()->isImmutable( QStringLiteral( "KeepCacheInMemory" ) );
    }

    /**
      Set MaximumCacheSize
    */
    static
    void setMaximumCacheSize( int v )
    {
      if (!self()->isMaximumCacheSizeImmutable())
        self()->mMaximumCacheSize = v;
    }

    /**
      Get MaximumCacheSize
    */
    static
    int maximumCacheSize()
    {
      return self()->mMaximumCacheSize;
    }

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

    /**
      Set CustomCacheDir
    */
    static
    void setCustomCacheDir( const QString & v )
    {
      if (!self()->isCustomCacheDirImmutable())
        self()->mCustomCacheDir = v;
    }

    /**
      Get CustomCacheDir
    */
    static
    QString customCacheDir()
    {
      return self()->mCustomCacheDir;
    }

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

    /**
      Set UseDefaultUserAgent
    */
    static
    void setUseDefaultUserAgent( bool v )
    {
      if (!self()->isUseDefaultUserAgentImmutable())
        self()->mUseDefaultUserAgent = v;
    }

    /**
      Get UseDefaultUserAgent
    */
    static
    bool useDefaultUserAgent()
    {
      return self()->mUseDefaultUserAgent;
    }

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

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

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

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

    /**
      Set Cookies
    */
    static
    void setCookiesEnabled( bool v )
    {
      if (!self()->isCookiesEnabledImmutable())
        self()->mCookiesEnabled = v;
    }

    /**
      Get Cookies
    */
    static
    bool cookiesEnabled()
    {
      return self()->mCookiesEnabled;
    }

    /**
      Is Cookies Immutable
    */
    static
    bool isCookiesEnabledImmutable()
    {
      return self()->isImmutable( QStringLiteral( "cookiesEnabled" ) );
    }

    /**
      Set RejectCrossDomainCookies
    */
    static
    void setRejectCrossDomainCookies( bool v )
    {
      if (!self()->isRejectCrossDomainCookiesImmutable())
        self()->mRejectCrossDomainCookies = v;
    }

    /**
      Get RejectCrossDomainCookies
    */
    static
    bool rejectCrossDomainCookies()
    {
      return self()->mRejectCrossDomainCookies;
    }

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

    /**
      Set AcceptSessionCookies
    */
    static
    void setAcceptSessionCookies( bool v )
    {
      if (!self()->isAcceptSessionCookiesImmutable())
        self()->mAcceptSessionCookies = v;
    }

    /**
      Get AcceptSessionCookies
    */
    static
    bool acceptSessionCookies()
    {
      return self()->mAcceptSessionCookies;
    }

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

    /**
      Set CookieGlobalAdvice
    */
    static
    void setCookieGlobalAdviceRaw( int v )
    {
      if (!self()->isCookieGlobalAdviceRawImmutable())
        self()->mCookieGlobalAdviceRaw = v;
    }

    /**
      Get CookieGlobalAdvice
    */
    static
    int cookieGlobalAdviceRaw()
    {
      return self()->mCookieGlobalAdviceRaw;
    }

    /**
      Is CookieGlobalAdvice Immutable
    */
    static
    bool isCookieGlobalAdviceRawImmutable()
    {
      return self()->isImmutable( QStringLiteral( "CookieGlobalAdviceRaw" ) );
    }

    /**
      Set CookieDomainAdvice
    */
    static
    void setCookieDomainAdviceRaw( const QString & v )
    {
      if (!self()->isCookieDomainAdviceRawImmutable())
        self()->mCookieDomainAdviceRaw = v;
    }

    /**
      Get CookieDomainAdvice
    */
    static
    QString cookieDomainAdviceRaw()
    {
      return self()->mCookieDomainAdviceRaw;
    }

    /**
      Is CookieDomainAdvice Immutable
    */
    static
    bool isCookieDomainAdviceRawImmutable()
    {
      return self()->isImmutable( QStringLiteral( "CookieDomainAdviceRaw" ) );
    }

    /**
      Set LocationBar
    */
    static
    void setLocationBarInJsWindows( bool v )
    {
      if (!self()->isLocationBarInJsWindowsImmutable())
        self()->mLocationBarInJsWindows = v;
    }

    /**
      Get LocationBar
    */
    static
    bool locationBarInJsWindows()
    {
      return self()->mLocationBarInJsWindows;
    }

    /**
      Is LocationBar Immutable
    */
    static
    bool isLocationBarInJsWindowsImmutable()
    {
      return self()->isImmutable( QStringLiteral( "locationBarInJsWindows" ) );
    }

  protected:
    Settings();
    friend class SettingsHelper;


    // UserSettings
    QString mStartURL;
    QString mHomeURL;
    bool mAlwaysDuplicatePageWhenSplittingView;
    bool mRestoreLastState;

    // UndoManagerSettings
    int mMaxNumClosedItems;

    // FMSettings
    bool mAlwaysNewWin;
    bool mShowFileTips;
    int mFileTipsItems;
    bool mShowPreviewsInFileTips;
    bool mShowDeleteCommand;
    bool mMmbOpensTab;
    bool mAlwaysTabbedMode;
    bool mNewTabsInFront;
    bool mOpenAfterCurrentPage;
    bool mPermanentCloseButton;
    bool mKonquerorTabforExternalURL;
    bool mPopupsWithinTabs;
    bool mTabCloseActivatePrevious;
    bool mMouseMiddleClickClosesTab;
    bool mAddTabButton;
    bool mCloseTabButton;
    int mMaximumTabLength;
    int mMinimumTabLength;
    int mTabBarPosition;
    int mOpenWithItems;

    // HTML Settings
    QFont mStandardFont;
    int mMediumFontSize;
    int mMinimumFontSize;
    QStringList mFonts;
    QString mDefaultEncoding;
    bool mHtmlUnderlineLinks;
    bool mHoverLinks;
    bool mAutoLoadImages;
    QString mShowAnimations;
    bool mFormCompletion;
    int mMaxFormCompletionItems;
    bool mUseInternalPDFViewer;
    bool mAlwaysEmbedInNewTab;
    bool mEnableFavicon;
    int mAutomaticDetectionLanguage;
    bool mEnforceDefaultCharset;
    bool mUserStyleSheetEnabled;

    // MainView Settings
    bool mOpenMiddleClick;
    bool mBackRightClick;
    bool mOfferToSaveWebsitePassword;
    QStringList mToggableViewsShown;

    // HistorySettings
    QString mOpenGroups;
    int mMaximumHistoryEntriesPerView;
    int mDefaultAction;
    int mMaximumHistoryEntryAge;

    // Java/JavaScript Settings
    QStringList mEcmaDomains;
    QStringList mECMADomainSettings;
    bool mEnableJavaScript;
    uint mWindowOpenPolicy;
    uint mWindowResizePolicy;
    uint mWindowMovePolicy;
    uint mWindowFocusPolicy;
    uint mWindowStatusPolicy;
    bool mEnablePlugins;
    QStringList mPluginDomains;

    // Notification Messages
    bool mMultipleTabConfirm;
    QString mPlugin_application_x_shockwave_flash;
    QString mPlugin_image_svg_xml;

    // Reusing
    bool mAlwaysHavePreloaded;
    bool mPreloadOnStartup;

    // Settings
    QString mBgImage;
    bool mSaveURLInProfile;
    int mSettingsCompletionMode;
    int mNumberofmostvisitedURLs;

    // Trash
    bool mConfirmDelete;
    bool mConfirmTrash;
    bool mOpenTabsInsideCurrentWindow;

    // SessionManagerSettings
    int mAutoSaveInterval;

    // Cache
    bool mCacheEnabled;
    bool mKeepCacheInMemory;
    int mMaximumCacheSize;
    QString mCustomCacheDir;

    // UserAgent
    bool mUseDefaultUserAgent;
    QString mCustomUserAgent;

    // Cookie Policy
    bool mCookiesEnabled;
    bool mRejectCrossDomainCookies;
    bool mAcceptSessionCookies;
    int mCookieGlobalAdviceRaw;
    QString mCookieDomainAdviceRaw;

    // DisableWindowOpenFeatures
    bool mLocationBarInJsWindows;
};

}

#endif

