settings_base.h

Go to the documentation of this file.

// This file is generated by kconfig_compiler from knode.kcfg.
// All changes you do to this file will be lost.
#ifndef KNODE_SETTINGSBASE_H
#define KNODE_SETTINGSBASE_H

#include <qapplication.h>
#include <knode_export.h>
#include <kmime/kmime_dateformatter.h>

#include <kglobal.h>
#include <kconfigskeleton.h>
#include <kdebug.h>

#include <kglobalsettings.h>
#include <kcolorscheme.h>
namespace KNode {

class KNODE_EXPORT SettingsBase : public KConfigSkeleton
{
  public:

    SettingsBase( );
    ~SettingsBase();

    void setIdentity( int v )
    {
      if (!isImmutable( QString::fromLatin1( "identity" ) ))
        mIdentity = v;
    }

    int identity() const
    {
      return mIdentity;
    }

    ItemInt *identityItem()
    {
      return mIdentityItem;
    }

    void setAutoCheckGroups( bool v )
    {
      if (!isImmutable( QString::fromLatin1( "autoCheckGroups" ) ))
        mAutoCheckGroups = v;
    }

    bool autoCheckGroups() const
    {
      return mAutoCheckGroups;
    }

    ItemBool *autoCheckGroupsItem()
    {
      return mAutoCheckGroupsItem;
    }

    void setMaxToFetch( int v )
    {
      if (!isImmutable( QString::fromLatin1( "maxToFetch" ) ))
        mMaxToFetch = v;
    }

    int maxToFetch() const
    {
      return mMaxToFetch;
    }

    ItemInt *maxToFetchItem()
    {
      return mMaxToFetchItem;
    }

    void setAutoMark( bool v )
    {
      if (!isImmutable( QString::fromLatin1( "autoMark" ) ))
        mAutoMark = v;
    }

    bool autoMark() const
    {
      return mAutoMark;
    }

    ItemBool *autoMarkItem()
    {
      return mAutoMarkItem;
    }

    void setAutoMarkSeconds( int v )
    {
      if (!isImmutable( QString::fromLatin1( "autoMarkSeconds" ) ))
        mAutoMarkSeconds = v;
    }

    int autoMarkSeconds() const
    {
      return mAutoMarkSeconds;
    }

    ItemInt *autoMarkSecondsItem()
    {
      return mAutoMarkSecondsItem;
    }

    void setMarkCrossposts( bool v )
    {
      if (!isImmutable( QString::fromLatin1( "markCrossposts" ) ))
        mMarkCrossposts = v;
    }

    bool markCrossposts() const
    {
      return mMarkCrossposts;
    }

    ItemBool *markCrosspostsItem()
    {
      return mMarkCrosspostsItem;
    }

    void setSmartScrolling( bool v )
    {
      if (!isImmutable( QString::fromLatin1( "smartScrolling" ) ))
        mSmartScrolling = v;
    }

    bool smartScrolling() const
    {
      return mSmartScrolling;
    }

    ItemBool *smartScrollingItem()
    {
      return mSmartScrollingItem;
    }

    void setTotalExpandThreads( bool v )
    {
      if (!isImmutable( QString::fromLatin1( "totalExpandThreads" ) ))
        mTotalExpandThreads = v;
    }

    bool totalExpandThreads() const
    {
      return mTotalExpandThreads;
    }

    ItemBool *totalExpandThreadsItem()
    {
      return mTotalExpandThreadsItem;
    }

    void setDefaultToExpandedThreads( bool v )
    {
      if (!isImmutable( QString::fromLatin1( "defaultToExpandedThreads" ) ))
        mDefaultToExpandedThreads = v;
    }

    bool defaultToExpandedThreads() const
    {
      return mDefaultToExpandedThreads;
    }

    ItemBool *defaultToExpandedThreadsItem()
    {
      return mDefaultToExpandedThreadsItem;
    }

    void setShowLines( bool v )
    {
      if (!isImmutable( QString::fromLatin1( "showLines" ) ))
        mShowLines = v;
    }

    bool showLines() const
    {
      return mShowLines;
    }

    ItemBool *showLinesItem()
    {
      return mShowLinesItem;
    }

    void setShowScore( bool v )
    {
      if (!isImmutable( QString::fromLatin1( "showScore" ) ))
        mShowScore = v;
    }

    bool showScore() const
    {
      return mShowScore;
    }

    ItemBool *showScoreItem()
    {
      return mShowScoreItem;
    }

    void setShowUnread( bool v )
    {
      if (!isImmutable( QString::fromLatin1( "showUnread" ) ))
        mShowUnread = v;
    }

    bool showUnread() const
    {
      return mShowUnread;
    }

    ItemBool *showUnreadItem()
    {
      return mShowUnreadItem;
    }

    void setShowThreads( bool v )
    {
      if (!isImmutable( QString::fromLatin1( "showThreads" ) ))
        mShowThreads = v;
    }

    bool showThreads() const
    {
      return mShowThreads;
    }

    ItemBool *showThreadsItem()
    {
      return mShowThreadsItem;
    }

    void setDateFormat( KMime::DateFormatter::FormatType v )
    {
      if (!isImmutable( QString::fromLatin1( "dateFormat" ) ))
        mDateFormat = v;
    }

    KMime::DateFormatter::FormatType dateFormat() const
    {
      return static_cast<KMime::DateFormatter::FormatType>(mDateFormat);
    }

    ItemEnum *dateFormatItem()
    {
      return mDateFormatItem;
    }

    void setCustomDateFormat( const QString & v )
    {
      if (!isImmutable( QString::fromLatin1( "customDateFormat" ) ))
        mCustomDateFormat = v;
    }

    QString customDateFormat() const
    {
      return mCustomDateFormat;
    }

    ItemString *customDateFormatItem()
    {
      return mCustomDateFormatItem;
    }

    void setRewrapBody( bool v )
    {
      if (!isImmutable( QString::fromLatin1( "rewrapBody" ) ))
        mRewrapBody = v;
    }

    bool rewrapBody() const
    {
      return mRewrapBody;
    }

    ItemBool *rewrapBodyItem()
    {
      return mRewrapBodyItem;
    }

    void setRemoveTrailingNewlines( bool v )
    {
      if (!isImmutable( QString::fromLatin1( "removeTrailingNewlines" ) ))
        mRemoveTrailingNewlines = v;
    }

    bool removeTrailingNewlines() const
    {
      return mRemoveTrailingNewlines;
    }

    ItemBool *removeTrailingNewlinesItem()
    {
      return mRemoveTrailingNewlinesItem;
    }

    void setShowSignature( bool v )
    {
      if (!isImmutable( QString::fromLatin1( "showSignature" ) ))
        mShowSignature = v;
    }

    bool showSignature() const
    {
      return mShowSignature;
    }

    ItemBool *showSignatureItem()
    {
      return mShowSignatureItem;
    }

    void setInterpretFormatTags( bool v )
    {
      if (!isImmutable( QString::fromLatin1( "interpretFormatTags" ) ))
        mInterpretFormatTags = v;
    }

    bool interpretFormatTags() const
    {
      return mInterpretFormatTags;
    }

    ItemBool *interpretFormatTagsItem()
    {
      return mInterpretFormatTagsItem;
    }

    void setQuoteCharacters( const QString & v )
    {
      if (!isImmutable( QString::fromLatin1( "quoteCharacters" ) ))
        mQuoteCharacters = v;
    }

    QString quoteCharacters() const
    {
      return mQuoteCharacters;
    }

    ItemString *quoteCharactersItem()
    {
      return mQuoteCharactersItem;
    }

    void setOpenAttachmentsOnClick( bool v )
    {
      if (!isImmutable( QString::fromLatin1( "openAttachmentsOnClick" ) ))
        mOpenAttachmentsOnClick = v;
    }

    bool openAttachmentsOnClick() const
    {
      return mOpenAttachmentsOnClick;
    }

    ItemBool *openAttachmentsOnClickItem()
    {
      return mOpenAttachmentsOnClickItem;
    }

    void setShowAlternativeContents( bool v )
    {
      if (!isImmutable( QString::fromLatin1( "showAlternativeContents" ) ))
        mShowAlternativeContents = v;
    }

    bool showAlternativeContents() const
    {
      return mShowAlternativeContents;
    }

    ItemBool *showAlternativeContentsItem()
    {
      return mShowAlternativeContentsItem;
    }

    void setUseFixedFont( bool v )
    {
      if (!isImmutable( QString::fromLatin1( "useFixedFont" ) ))
        mUseFixedFont = v;
    }

    bool useFixedFont() const
    {
      return mUseFixedFont;
    }

    ItemBool *useFixedFontItem()
    {
      return mUseFixedFontItem;
    }

    void setShowRefBar( bool v )
    {
      if (!isImmutable( QString::fromLatin1( "showRefBar" ) ))
        mShowRefBar = v;
    }

    bool showRefBar() const
    {
      return mShowRefBar;
    }

    ItemBool *showRefBarItem()
    {
      return mShowRefBarItem;
    }

    void setAlwaysShowHTML( bool v )
    {
      if (!isImmutable( QString::fromLatin1( "alwaysShowHTML" ) ))
        mAlwaysShowHTML = v;
    }

    bool alwaysShowHTML() const
    {
      return mAlwaysShowHTML;
    }

    ItemBool *alwaysShowHTMLItem()
    {
      return mAlwaysShowHTMLItem;
    }

    void setAllowExternalReferences( bool v )
    {
      if (!isImmutable( QString::fromLatin1( "allowExternalReferences" ) ))
        mAllowExternalReferences = v;
    }

    bool allowExternalReferences() const
    {
      return mAllowExternalReferences;
    }

    ItemBool *allowExternalReferencesItem()
    {
      return mAllowExternalReferencesItem;
    }

    void setMarkAllReadGoNext( bool v )
    {
      if (!isImmutable( QString::fromLatin1( "markAllReadGoNext" ) ))
        mMarkAllReadGoNext = v;
    }

    bool markAllReadGoNext() const
    {
      return mMarkAllReadGoNext;
    }

    ItemBool *markAllReadGoNextItem()
    {
      return mMarkAllReadGoNextItem;
    }

    void setMarkThreadReadGoNext( bool v )
    {
      if (!isImmutable( QString::fromLatin1( "markThreadReadGoNext" ) ))
        mMarkThreadReadGoNext = v;
    }

    bool markThreadReadGoNext() const
    {
      return mMarkThreadReadGoNext;
    }

    ItemBool *markThreadReadGoNextItem()
    {
      return mMarkThreadReadGoNextItem;
    }

    void setMarkThreadReadCloseThread( bool v )
    {
      if (!isImmutable( QString::fromLatin1( "markThreadReadCloseThread" ) ))
        mMarkThreadReadCloseThread = v;
    }

    bool markThreadReadCloseThread() const
    {
      return mMarkThreadReadCloseThread;
    }

    ItemBool *markThreadReadCloseThreadItem()
    {
      return mMarkThreadReadCloseThreadItem;
    }

    void setIgnoreThreadGoNext( bool v )
    {
      if (!isImmutable( QString::fromLatin1( "ignoreThreadGoNext" ) ))
        mIgnoreThreadGoNext = v;
    }

    bool ignoreThreadGoNext() const
    {
      return mIgnoreThreadGoNext;
    }

    ItemBool *ignoreThreadGoNextItem()
    {
      return mIgnoreThreadGoNextItem;
    }

    void setIgnoreThreadCloseThread( bool v )
    {
      if (!isImmutable( QString::fromLatin1( "ignoreThreadCloseThread" ) ))
        mIgnoreThreadCloseThread = v;
    }

    bool ignoreThreadCloseThread() const
    {
      return mIgnoreThreadCloseThread;
    }

    ItemBool *ignoreThreadCloseThreadItem()
    {
      return mIgnoreThreadCloseThreadItem;
    }

    void setLeaveGroupMarkAsRead( bool v )
    {
      if (!isImmutable( QString::fromLatin1( "leaveGroupMarkAsRead" ) ))
        mLeaveGroupMarkAsRead = v;
    }

    bool leaveGroupMarkAsRead() const
    {
      return mLeaveGroupMarkAsRead;
    }

    ItemBool *leaveGroupMarkAsReadItem()
    {
      return mLeaveGroupMarkAsReadItem;
    }

    void setIgnoredThreshold( int v )
    {
      if (!isImmutable( QString::fromLatin1( "ignoredThreshold" ) ))
        mIgnoredThreshold = v;
    }

    int ignoredThreshold() const
    {
      return mIgnoredThreshold;
    }

    ItemInt *ignoredThresholdItem()
    {
      return mIgnoredThresholdItem;
    }

    void setWatchedThreshold( int v )
    {
      if (!isImmutable( QString::fromLatin1( "watchedThreshold" ) ))
        mWatchedThreshold = v;
    }

    int watchedThreshold() const
    {
      return mWatchedThreshold;
    }

    ItemInt *watchedThresholdItem()
    {
      return mWatchedThresholdItem;
    }

    void setCollCacheSize( int v )
    {
      if (!isImmutable( QString::fromLatin1( "collCacheSize" ) ))
        mCollCacheSize = v;
    }

    int collCacheSize() const
    {
      return mCollCacheSize;
    }

    ItemInt *collCacheSizeItem()
    {
      return mCollCacheSizeItem;
    }

    void setArtCacheSize( int v )
    {
      if (!isImmutable( QString::fromLatin1( "artCacheSize" ) ))
        mArtCacheSize = v;
    }

    int artCacheSize() const
    {
      return mArtCacheSize;
    }

    ItemInt *artCacheSizeItem()
    {
      return mArtCacheSizeItem;
    }

    void setUseOwnCharset( bool v )
    {
      if (!isImmutable( QString::fromLatin1( "UseOwnCharset" ) ))
        mUseOwnCharset = v;
    }

    bool useOwnCharset() const
    {
      return mUseOwnCharset;
    }

    ItemBool *useOwnCharsetItem()
    {
      return mUseOwnCharsetItem;
    }

    void setHostname( const QString & v )
    {
      if (!isImmutable( QString::fromLatin1( "hostname" ) ))
        mHostname = v;
    }

    QString hostname() const
    {
      return mHostname;
    }

    ItemString *hostnameItem()
    {
      return mHostnameItem;
    }

    void setGenerateMessageID( bool v )
    {
      if (!isImmutable( QString::fromLatin1( "generateMessageID" ) ))
        mGenerateMessageID = v;
    }

    bool generateMessageID() const
    {
      return mGenerateMessageID;
    }

    ItemBool *generateMessageIDItem()
    {
      return mGenerateMessageIDItem;
    }

    void setNoUserAgent( bool v )
    {
      if (!isImmutable( QString::fromLatin1( "noUserAgent" ) ))
        mNoUserAgent = v;
    }

    bool noUserAgent() const
    {
      return mNoUserAgent;
    }

    ItemBool *noUserAgentItem()
    {
      return mNoUserAgentItem;
    }

    void setUseExternalMailer( bool v )
    {
      if (!isImmutable( QString::fromLatin1( "useExternalMailer" ) ))
        mUseExternalMailer = v;
    }

    bool useExternalMailer() const
    {
      return mUseExternalMailer;
    }

    ItemBool *useExternalMailerItem()
    {
      return mUseExternalMailerItem;
    }

    void setAllow8BitBody( bool v )
    {
      if (!isImmutable( QString::fromLatin1( "allow8BitBody" ) ))
        mAllow8BitBody = v;
    }

    bool allow8BitBody() const
    {
      return mAllow8BitBody;
    }

    ItemBool *allow8BitBodyItem()
    {
      return mAllow8BitBodyItem;
    }

    void setCharset( const QString & v )
    {
      if (!isImmutable( QString::fromLatin1( "Charset" ) ))
        mCharset = v;
    }

    QString charset() const
    {
      return mCharset;
    }

    ItemString *charsetItem()
    {
      return mCharsetItem;
    }

    void setWordWrap( bool v )
    {
      if (!isImmutable( QString::fromLatin1( "wordWrap" ) ))
        mWordWrap = v;
    }

    bool wordWrap() const
    {
      return mWordWrap;
    }

    ItemBool *wordWrapItem()
    {
      return mWordWrapItem;
    }

    void setAutoSpellChecking( bool v )
    {
      if (!isImmutable( QString::fromLatin1( "autoSpellChecking" ) ))
        mAutoSpellChecking = v;
    }

    bool autoSpellChecking() const
    {
      return mAutoSpellChecking;
    }

    ItemBool *autoSpellCheckingItem()
    {
      return mAutoSpellCheckingItem;
    }

    void setMaxLineLength( int v )
    {
      if (!isImmutable( QString::fromLatin1( "maxLineLength" ) ))
        mMaxLineLength = v;
    }

    int maxLineLength() const
    {
      return mMaxLineLength;
    }

    ItemInt *maxLineLengthItem()
    {
      return mMaxLineLengthItem;
    }

    void setAppendOwnSignature( bool v )
    {
      if (!isImmutable( QString::fromLatin1( "appendOwnSignature" ) ))
        mAppendOwnSignature = v;
    }

    bool appendOwnSignature() const
    {
      return mAppendOwnSignature;
    }

    ItemBool *appendOwnSignatureItem()
    {
      return mAppendOwnSignatureItem;
    }

    void setRewrap( bool v )
    {
      if (!isImmutable( QString::fromLatin1( "rewrap" ) ))
        mRewrap = v;
    }

    bool rewrap() const
    {
      return mRewrap;
    }

    ItemBool *rewrapItem()
    {
      return mRewrapItem;
    }

    void setIncludeSignature( bool v )
    {
      if (!isImmutable( QString::fromLatin1( "includeSignature" ) ))
        mIncludeSignature = v;
    }

    bool includeSignature() const
    {
      return mIncludeSignature;
    }

    ItemBool *includeSignatureItem()
    {
      return mIncludeSignatureItem;
    }

    void setCursorOnTop( bool v )
    {
      if (!isImmutable( QString::fromLatin1( "cursorOnTop" ) ))
        mCursorOnTop = v;
    }

    bool cursorOnTop() const
    {
      return mCursorOnTop;
    }

    ItemBool *cursorOnTopItem()
    {
      return mCursorOnTopItem;
    }

    void setUseExternalEditor( bool v )
    {
      if (!isImmutable( QString::fromLatin1( "useExternalEditor" ) ))
        mUseExternalEditor = v;
    }

    bool useExternalEditor() const
    {
      return mUseExternalEditor;
    }

    ItemBool *useExternalEditorItem()
    {
      return mUseExternalEditorItem;
    }

    void setIntro( const QString & v )
    {
      if (!isImmutable( QString::fromLatin1( "Intro" ) ))
        mIntro = v;
    }

    QString intro() const
    {
      return mIntro;
    }

    ItemString *introItem()
    {
      return mIntroItem;
    }

    void setExternalEditor( const QString & v )
    {
      if (!isImmutable( QString::fromLatin1( "externalEditor" ) ))
        mExternalEditor = v;
    }

    QString externalEditor() const
    {
      return mExternalEditor;
    }

    ItemString *externalEditorItem()
    {
      return mExternalEditorItem;
    }

    void setUseCustomColors( bool v )
    {
      if (!isImmutable( QString::fromLatin1( "useCustomColors" ) ))
        mUseCustomColors = v;
    }

    bool useCustomColors() const
    {
      return mUseCustomColors;
    }

    ItemBool *useCustomColorsItem()
    {
      return mUseCustomColorsItem;
    }

    void setBackgroundColor( const QColor & v )
    {
      if (!isImmutable( QString::fromLatin1( "backgroundColor" ) ))
        mBackgroundColor = v;
    }

    QColor backgroundColor() const
    {
      return mBackgroundColor;
    }

    ItemColor *backgroundColorItem()
    {
      return mBackgroundColorItem;
    }

    void setAlternateBackgroundColor( const QColor & v )
    {
      if (!isImmutable( QString::fromLatin1( "alternateBackgroundColor" ) ))
        mAlternateBackgroundColor = v;
    }

    QColor alternateBackgroundColor() const
    {
      return mAlternateBackgroundColor;
    }

    ItemColor *alternateBackgroundColorItem()
    {
      return mAlternateBackgroundColorItem;
    }

    void setTextColor( const QColor & v )
    {
      if (!isImmutable( QString::fromLatin1( "textColor" ) ))
        mTextColor = v;
    }

    QColor textColor() const
    {
      return mTextColor;
    }

    ItemColor *textColorItem()
    {
      return mTextColorItem;
    }

    void setQuoteColor( int i, const QColor & v )
    {
      if (!isImmutable( QString::fromLatin1( "quote%1Color" ).arg( i ) ))
        mQuoteColor[i] = v;
    }

    QColor quoteColor( int i ) const
    {
      return mQuoteColor[i];
    }

    ItemColor *quoteColorItem( int i )
    {
      return mQuoteColorItem[i];
    }

    void setLinkColor( const QColor & v )
    {
      if (!isImmutable( QString::fromLatin1( "linkColor" ) ))
        mLinkColor = v;
    }

    QColor linkColor() const
    {
      return mLinkColor;
    }

    ItemColor *linkColorItem()
    {
      return mLinkColorItem;
    }

    void setReadThreadColor( const QColor & v )
    {
      if (!isImmutable( QString::fromLatin1( "readThreadColor" ) ))
        mReadThreadColor = v;
    }

    QColor readThreadColor() const
    {
      return mReadThreadColor;
    }

    ItemColor *readThreadColorItem()
    {
      return mReadThreadColorItem;
    }

    void setUnreadThreadColor( const QColor & v )
    {
      if (!isImmutable( QString::fromLatin1( "unreadThreadColor" ) ))
        mUnreadThreadColor = v;
    }

    QColor unreadThreadColor() const
    {
      return mUnreadThreadColor;
    }

    ItemColor *unreadThreadColorItem()
    {
      return mUnreadThreadColorItem;
    }

    void setReadArticleColor( const QColor & v )
    {
      if (!isImmutable( QString::fromLatin1( "readArticleColor" ) ))
        mReadArticleColor = v;
    }

    QColor readArticleColor() const
    {
      return mReadArticleColor;
    }

    ItemColor *readArticleColorItem()
    {
      return mReadArticleColorItem;
    }

    void setUnreadArticleColor( const QColor & v )
    {
      if (!isImmutable( QString::fromLatin1( "unreadArticleColor" ) ))
        mUnreadArticleColor = v;
    }

    QColor unreadArticleColor() const
    {
      return mUnreadArticleColor;
    }

    ItemColor *unreadArticleColorItem()
    {
      return mUnreadArticleColorItem;
    }

    void setSignOkKeyOkColor( const QColor & v )
    {
      if (!isImmutable( QString::fromLatin1( "signOkKeyOkColor" ) ))
        mSignOkKeyOkColor = v;
    }

    QColor signOkKeyOkColor() const
    {
      return mSignOkKeyOkColor;
    }

    ItemColor *signOkKeyOkColorItem()
    {
      return mSignOkKeyOkColorItem;
    }

    void setSignOkKeyBadColor( const QColor & v )
    {
      if (!isImmutable( QString::fromLatin1( "signOkKeyBadColor" ) ))
        mSignOkKeyBadColor = v;
    }

    QColor signOkKeyBadColor() const
    {
      return mSignOkKeyBadColor;
    }

    ItemColor *signOkKeyBadColorItem()
    {
      return mSignOkKeyBadColorItem;
    }

    void setSignWarnColor( const QColor & v )
    {
      if (!isImmutable( QString::fromLatin1( "signWarnColor" ) ))
        mSignWarnColor = v;
    }

    QColor signWarnColor() const
    {
      return mSignWarnColor;
    }

    ItemColor *signWarnColorItem()
    {
      return mSignWarnColorItem;
    }

    void setSignErrColor( const QColor & v )
    {
      if (!isImmutable( QString::fromLatin1( "signErrColor" ) ))
        mSignErrColor = v;
    }

    QColor signErrColor() const
    {
      return mSignErrColor;
    }

    ItemColor *signErrColorItem()
    {
      return mSignErrColorItem;
    }

    void setHtmlWarningColor( const QColor & v )
    {
      if (!isImmutable( QString::fromLatin1( "htmlWarningColor" ) ))
        mHtmlWarningColor = v;
    }

    QColor htmlWarningColor() const
    {
      return mHtmlWarningColor;
    }

    ItemColor *htmlWarningColorItem()
    {
      return mHtmlWarningColorItem;
    }

    void setUseCustomFonts( bool v )
    {
      if (!isImmutable( QString::fromLatin1( "useCustomFonts" ) ))
        mUseCustomFonts = v;
    }

    bool useCustomFonts() const
    {
      return mUseCustomFonts;
    }

    ItemBool *useCustomFontsItem()
    {
      return mUseCustomFontsItem;
    }

    void setArticleFont( const QFont & v )
    {
      if (!isImmutable( QString::fromLatin1( "articleFont" ) ))
        mArticleFont = v;
    }

    QFont articleFont() const
    {
      return mArticleFont;
    }

    ItemFont *articleFontItem()
    {
      return mArticleFontItem;
    }

    void setArticleFixedFont( const QFont & v )
    {
      if (!isImmutable( QString::fromLatin1( "articleFixedFont" ) ))
        mArticleFixedFont = v;
    }

    QFont articleFixedFont() const
    {
      return mArticleFixedFont;
    }

    ItemFont *articleFixedFontItem()
    {
      return mArticleFixedFontItem;
    }

    void setComposerFont( const QFont & v )
    {
      if (!isImmutable( QString::fromLatin1( "composerFont" ) ))
        mComposerFont = v;
    }

    QFont composerFont() const
    {
      return mComposerFont;
    }

    ItemFont *composerFontItem()
    {
      return mComposerFontItem;
    }

    void setGroupListFont( const QFont & v )
    {
      if (!isImmutable( QString::fromLatin1( "groupListFont" ) ))
        mGroupListFont = v;
    }

    QFont groupListFont() const
    {
      return mGroupListFont;
    }

    ItemFont *groupListFontItem()
    {
      return mGroupListFontItem;
    }

    void setArticleListFont( const QFont & v )
    {
      if (!isImmutable( QString::fromLatin1( "articleListFont" ) ))
        mArticleListFont = v;
    }

    QFont articleListFont() const
    {
      return mArticleListFont;
    }

    ItemFont *articleListFontItem()
    {
      return mArticleListFontItem;
    }

  protected:

    // IDENTITY
    int mIdentity;

    // READNEWS
    bool mAutoCheckGroups;
    int mMaxToFetch;
    bool mAutoMark;
    int mAutoMarkSeconds;
    bool mMarkCrossposts;
    bool mSmartScrolling;
    bool mTotalExpandThreads;
    bool mDefaultToExpandedThreads;
    bool mShowLines;
    bool mShowScore;
    bool mShowUnread;
    bool mShowThreads;
    int mDateFormat;
    QString mCustomDateFormat;
    bool mRewrapBody;
    bool mRemoveTrailingNewlines;
    bool mShowSignature;
    bool mInterpretFormatTags;
    QString mQuoteCharacters;
    bool mOpenAttachmentsOnClick;
    bool mShowAlternativeContents;
    bool mUseFixedFont;
    bool mShowRefBar;
    bool mAlwaysShowHTML;
    bool mAllowExternalReferences;

    // READNEWS_NAVIGATION
    bool mMarkAllReadGoNext;
    bool mMarkThreadReadGoNext;
    bool mMarkThreadReadCloseThread;
    bool mIgnoreThreadGoNext;
    bool mIgnoreThreadCloseThread;
    bool mLeaveGroupMarkAsRead;

    // SCORING
    int mIgnoredThreshold;
    int mWatchedThreshold;

    // CACHE
    int mCollCacheSize;
    int mArtCacheSize;

    // POSTNEWS
    bool mUseOwnCharset;
    QString mHostname;
    bool mGenerateMessageID;
    bool mNoUserAgent;
    bool mUseExternalMailer;
    bool mAllow8BitBody;
    QString mCharset;
    bool mWordWrap;
    bool mAutoSpellChecking;
    int mMaxLineLength;
    bool mAppendOwnSignature;
    bool mRewrap;
    bool mIncludeSignature;
    bool mCursorOnTop;
    bool mUseExternalEditor;
    QString mIntro;
    QString mExternalEditor;

    // VISUAL_APPEARANCE
    bool mUseCustomColors;
    QColor mBackgroundColor;
    QColor mAlternateBackgroundColor;
    QColor mTextColor;
    QColor mQuoteColor[3];
    QColor mLinkColor;
    QColor mReadThreadColor;
    QColor mUnreadThreadColor;
    QColor mReadArticleColor;
    QColor mUnreadArticleColor;
    QColor mSignOkKeyOkColor;
    QColor mSignOkKeyBadColor;
    QColor mSignWarnColor;
    QColor mSignErrColor;
    QColor mHtmlWarningColor;
    bool mUseCustomFonts;
    QFont mArticleFont;
    QFont mArticleFixedFont;
    QFont mComposerFont;
    QFont mGroupListFont;
    QFont mArticleListFont;

  private:
    ItemInt *mIdentityItem;
    ItemBool *mAutoCheckGroupsItem;
    ItemInt *mMaxToFetchItem;
    ItemBool *mAutoMarkItem;
    ItemInt *mAutoMarkSecondsItem;
    ItemBool *mMarkCrosspostsItem;
    ItemBool *mSmartScrollingItem;
    ItemBool *mTotalExpandThreadsItem;
    ItemBool *mDefaultToExpandedThreadsItem;
    ItemBool *mShowLinesItem;
    ItemBool *mShowScoreItem;
    ItemBool *mShowUnreadItem;
    ItemBool *mShowThreadsItem;
    ItemEnum *mDateFormatItem;
    ItemString *mCustomDateFormatItem;
    ItemBool *mRewrapBodyItem;
    ItemBool *mRemoveTrailingNewlinesItem;
    ItemBool *mShowSignatureItem;
    ItemBool *mInterpretFormatTagsItem;
    ItemString *mQuoteCharactersItem;
    ItemBool *mOpenAttachmentsOnClickItem;
    ItemBool *mShowAlternativeContentsItem;
    ItemBool *mUseFixedFontItem;
    ItemBool *mShowRefBarItem;
    ItemBool *mAlwaysShowHTMLItem;
    ItemBool *mAllowExternalReferencesItem;
    ItemBool *mMarkAllReadGoNextItem;
    ItemBool *mMarkThreadReadGoNextItem;
    ItemBool *mMarkThreadReadCloseThreadItem;
    ItemBool *mIgnoreThreadGoNextItem;
    ItemBool *mIgnoreThreadCloseThreadItem;
    ItemBool *mLeaveGroupMarkAsReadItem;
    ItemInt *mIgnoredThresholdItem;
    ItemInt *mWatchedThresholdItem;
    ItemInt *mCollCacheSizeItem;
    ItemInt *mArtCacheSizeItem;
    ItemBool *mUseOwnCharsetItem;
    ItemString *mHostnameItem;
    ItemBool *mGenerateMessageIDItem;
    ItemBool *mNoUserAgentItem;
    ItemBool *mUseExternalMailerItem;
    ItemBool *mAllow8BitBodyItem;
    ItemString *mCharsetItem;
    ItemBool *mWordWrapItem;
    ItemBool *mAutoSpellCheckingItem;
    ItemInt *mMaxLineLengthItem;
    ItemBool *mAppendOwnSignatureItem;
    ItemBool *mRewrapItem;
    ItemBool *mIncludeSignatureItem;
    ItemBool *mCursorOnTopItem;
    ItemBool *mUseExternalEditorItem;
    ItemString *mIntroItem;
    ItemString *mExternalEditorItem;
    ItemBool *mUseCustomColorsItem;
    ItemColor *mBackgroundColorItem;
    ItemColor *mAlternateBackgroundColorItem;
    ItemColor *mTextColorItem;
    ItemColor *mQuoteColorItem[3];
    ItemColor *mLinkColorItem;
    ItemColor *mReadThreadColorItem;
    ItemColor *mUnreadThreadColorItem;
    ItemColor *mReadArticleColorItem;
    ItemColor *mUnreadArticleColorItem;
    ItemColor *mSignOkKeyOkColorItem;
    ItemColor *mSignOkKeyBadColorItem;
    ItemColor *mSignWarnColorItem;
    ItemColor *mSignErrColorItem;
    ItemColor *mHtmlWarningColorItem;
    ItemBool *mUseCustomFontsItem;
    ItemFont *mArticleFontItem;
    ItemFont *mArticleFixedFontItem;
    ItemFont *mComposerFontItem;
    ItemFont *mGroupListFontItem;
    ItemFont *mArticleListFontItem;
};

}

#endif