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

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

namespace Tellico {

class Config : public KConfigSkeleton
{
  public:
    enum EnumViewWidget { ListView, IconView };
    enum EnumImageLocation { ImagesInFile, ImagesInAppDir, ImagesInLocalDir };

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

    /**
      Set SortColumn
    */
    static
    void setGroupViewSortColumn( int v )
    {
      if (!self()->isGroupViewSortColumnImmutable())
        self()->mGroupViewSortColumn = v;
    }

    /**
      Get SortColumn
    */
    static
    int groupViewSortColumn()
    {
      return self()->mGroupViewSortColumn;
    }

    /**
      Is SortColumn Immutable
    */
    static
    bool isGroupViewSortColumnImmutable()
    {
      return self()->isImmutable( QStringLiteral( "groupViewSortColumn" ) );
    }

    /**
      Set SortAscending
    */
    static
    void setGroupViewSortAscending( bool v )
    {
      if (!self()->isGroupViewSortAscendingImmutable())
        self()->mGroupViewSortAscending = v;
    }

    /**
      Get SortAscending
    */
    static
    bool groupViewSortAscending()
    {
      return self()->mGroupViewSortAscending;
    }

    /**
      Is SortAscending Immutable
    */
    static
    bool isGroupViewSortAscendingImmutable()
    {
      return self()->isImmutable( QStringLiteral( "groupViewSortAscending" ) );
    }

    /**
      Set SortColumn
    */
    static
    void setFilterViewSortColumn( int v )
    {
      if (!self()->isFilterViewSortColumnImmutable())
        self()->mFilterViewSortColumn = v;
    }

    /**
      Get SortColumn
    */
    static
    int filterViewSortColumn()
    {
      return self()->mFilterViewSortColumn;
    }

    /**
      Is SortColumn Immutable
    */
    static
    bool isFilterViewSortColumnImmutable()
    {
      return self()->isImmutable( QStringLiteral( "filterViewSortColumn" ) );
    }

    /**
      Set SortAscending
    */
    static
    void setFilterViewSortAscending( bool v )
    {
      if (!self()->isFilterViewSortAscendingImmutable())
        self()->mFilterViewSortAscending = v;
    }

    /**
      Get SortAscending
    */
    static
    bool filterViewSortAscending()
    {
      return self()->mFilterViewSortAscending;
    }

    /**
      Is SortAscending Immutable
    */
    static
    bool isFilterViewSortAscendingImmutable()
    {
      return self()->isImmutable( QStringLiteral( "filterViewSortAscending" ) );
    }

    /**
      Set SortColumn
    */
    static
    void setLoanViewSortColumn( int v )
    {
      if (!self()->isLoanViewSortColumnImmutable())
        self()->mLoanViewSortColumn = v;
    }

    /**
      Get SortColumn
    */
    static
    int loanViewSortColumn()
    {
      return self()->mLoanViewSortColumn;
    }

    /**
      Is SortColumn Immutable
    */
    static
    bool isLoanViewSortColumnImmutable()
    {
      return self()->isImmutable( QStringLiteral( "loanViewSortColumn" ) );
    }

    /**
      Set SortAscending
    */
    static
    void setLoanViewSortAscending( bool v )
    {
      if (!self()->isLoanViewSortAscendingImmutable())
        self()->mLoanViewSortAscending = v;
    }

    /**
      Get SortAscending
    */
    static
    bool loanViewSortAscending()
    {
      return self()->mLoanViewSortAscending;
    }

    /**
      Is SortAscending Immutable
    */
    static
    bool isLoanViewSortAscendingImmutable()
    {
      return self()->isImmutable( QStringLiteral( "loanViewSortAscending" ) );
    }

    /**
      Set Use Braces
    */
    static
    void setUseBraces( bool v )
    {
      if (!self()->isUseBracesImmutable())
        self()->mUseBraces = v;
    }

    /**
      Get Use Braces
    */
    static
    bool useBraces()
    {
      return self()->mUseBraces;
    }

    /**
      Is Use Braces Immutable
    */
    static
    bool isUseBracesImmutable()
    {
      return self()->isImmutable( QStringLiteral( "UseBraces" ) );
    }

    /**
      Set Show Edit Widget
    */
    static
    void setShowEditWidget( bool v )
    {
      if (!self()->isShowEditWidgetImmutable())
        self()->mShowEditWidget = v;
    }

    /**
      Get Show Edit Widget
    */
    static
    bool showEditWidget()
    {
      return self()->mShowEditWidget;
    }

    /**
      Is Show Edit Widget Immutable
    */
    static
    bool isShowEditWidgetImmutable()
    {
      return self()->isImmutable( QStringLiteral( "ShowEditWidget" ) );
    }

    /**
      Set View Widget
    */
    static
    void setViewWidget( int v )
    {
      if (!self()->isViewWidgetImmutable())
        self()->mViewWidget = v;
    }

    /**
      Get View Widget
    */
    static
    int viewWidget()
    {
      return self()->mViewWidget;
    }

    /**
      Is View Widget Immutable
    */
    static
    bool isViewWidgetImmutable()
    {
      return self()->isImmutable( QStringLiteral( "ViewWidget" ) );
    }

    /**
      Set Lock Layout
    */
    static
    void setLockLayout( bool v )
    {
      if (!self()->isLockLayoutImmutable())
        self()->mLockLayout = v;
    }

    /**
      Get Lock Layout
    */
    static
    bool lockLayout()
    {
      return self()->mLockLayout;
    }

    /**
      Is Lock Layout Immutable
    */
    static
    bool isLockLayoutImmutable()
    {
      return self()->isImmutable( QStringLiteral( "LockLayout" ) );
    }

    /**
      Set Image Location
    */
    static
    void setImageLocation( int v )
    {
      if (!self()->isImageLocationImmutable())
        self()->mImageLocation = v;
    }

    /**
      Get Image Location
    */
    static
    int imageLocation()
    {
      return self()->mImageLocation;
    }

    /**
      Is Image Location Immutable
    */
    static
    bool isImageLocationImmutable()
    {
      return self()->isImmutable( QStringLiteral( "ImageLocation" ) );
    }

    /**
      Set Ask Write Images In File
    */
    static
    void setAskWriteImagesInFile( bool v )
    {
      if (!self()->isAskWriteImagesInFileImmutable())
        self()->mAskWriteImagesInFile = v;
    }

    /**
      Get Ask Write Images In File
    */
    static
    bool askWriteImagesInFile()
    {
      return self()->mAskWriteImagesInFile;
    }

    /**
      Is Ask Write Images In File Immutable
    */
    static
    bool isAskWriteImagesInFileImmutable()
    {
      return self()->isImmutable( QStringLiteral( "AskWriteImagesInFile" ) );
    }

    /**
      Set Reopen Last File
    */
    static
    void setReopenLastFile( bool v )
    {
      if (!self()->isReopenLastFileImmutable())
        self()->mReopenLastFile = v;
    }

    /**
      Get Reopen Last File
    */
    static
    bool reopenLastFile()
    {
      return self()->mReopenLastFile;
    }

    /**
      Is Reopen Last File Immutable
    */
    static
    bool isReopenLastFileImmutable()
    {
      return self()->isImmutable( QStringLiteral( "ReopenLastFile" ) );
    }

    /**
      Set Auto Capitalization
    */
    static
    void setAutoCapitalization( bool v )
    {
      if (!self()->isAutoCapitalizationImmutable())
        self()->mAutoCapitalization = v;
    }

    /**
      Get Auto Capitalization
    */
    static
    bool autoCapitalization()
    {
      return self()->mAutoCapitalization;
    }

    /**
      Is Auto Capitalization Immutable
    */
    static
    bool isAutoCapitalizationImmutable()
    {
      return self()->isImmutable( QStringLiteral( "AutoCapitalization" ) );
    }

    /**
      Set Auto Format
    */
    static
    void setAutoFormat( bool v )
    {
      if (!self()->isAutoFormatImmutable())
        self()->mAutoFormat = v;
    }

    /**
      Get Auto Format
    */
    static
    bool autoFormat()
    {
      return self()->mAutoFormat;
    }

    /**
      Is Auto Format Immutable
    */
    static
    bool isAutoFormatImmutable()
    {
      return self()->isImmutable( QStringLiteral( "AutoFormat" ) );
    }

    /**
      Set Last Open File
    */
    static
    void setLastOpenFile( const QString & v )
    {
      if (!self()->isLastOpenFileImmutable())
        self()->mLastOpenFile = v;
    }

    /**
      Get Last Open File
    */
    static
    QString lastOpenFile()
    {
      return self()->mLastOpenFile;
    }

    /**
      Is Last Open File Immutable
    */
    static
    bool isLastOpenFileImmutable()
    {
      return self()->isImmutable( QStringLiteral( "LastOpenFile" ) );
    }

    /**
      Set No Capitalization
    */
    static
    void setNoCapitalizationString( const QString & v )
    {
      if (!self()->isNoCapitalizationStringImmutable())
        self()->mNoCapitalizationString = v;
    }

    /**
      Get No Capitalization
    */
    static
    QString noCapitalizationString()
    {
      return self()->mNoCapitalizationString;
    }

    /**
      Is No Capitalization Immutable
    */
    static
    bool isNoCapitalizationStringImmutable()
    {
      return self()->isImmutable( QStringLiteral( "noCapitalizationString" ) );
    }

    /**
      Set Articles
    */
    static
    void setArticlesString( const QString & v )
    {
      if (!self()->isArticlesStringImmutable())
        self()->mArticlesString = v;
    }

    /**
      Get Articles
    */
    static
    QString articlesString()
    {
      return self()->mArticlesString;
    }

    /**
      Is Articles Immutable
    */
    static
    bool isArticlesStringImmutable()
    {
      return self()->isImmutable( QStringLiteral( "articlesString" ) );
    }

    /**
      Set Name Suffixes
    */
    static
    void setNameSuffixesString( const QString & v )
    {
      if (!self()->isNameSuffixesStringImmutable())
        self()->mNameSuffixesString = v;
    }

    /**
      Get Name Suffixes
    */
    static
    QString nameSuffixesString()
    {
      return self()->mNameSuffixesString;
    }

    /**
      Is Name Suffixes Immutable
    */
    static
    bool isNameSuffixesStringImmutable()
    {
      return self()->isImmutable( QStringLiteral( "nameSuffixesString" ) );
    }

    /**
      Set Surname Prefixes
    */
    static
    void setSurnamePrefixesString( const QString & v )
    {
      if (!self()->isSurnamePrefixesStringImmutable())
        self()->mSurnamePrefixesString = v;
    }

    /**
      Get Surname Prefixes
    */
    static
    QString surnamePrefixesString()
    {
      return self()->mSurnamePrefixesString;
    }

    /**
      Is Surname Prefixes Immutable
    */
    static
    bool isSurnamePrefixesStringImmutable()
    {
      return self()->isImmutable( QStringLiteral( "surnamePrefixesString" ) );
    }

    /**
      Set Max Icon Size
    */
    static
    void setMaxIconSize( int v )
    {
      if (!self()->isMaxIconSizeImmutable())
        self()->mMaxIconSize = v;
    }

    /**
      Get Max Icon Size
    */
    static
    int maxIconSize()
    {
      return self()->mMaxIconSize;
    }

    /**
      Is Max Icon Size Immutable
    */
    static
    bool isMaxIconSizeImmutable()
    {
      return self()->isImmutable( QStringLiteral( "MaxIconSize" ) );
    }

    /**
      Set Icon Cache Size
    */
    static
    void setIconCacheSize( int v )
    {
      if (!self()->isIconCacheSizeImmutable())
        self()->mIconCacheSize = v;
    }

    /**
      Get Icon Cache Size
    */
    static
    int iconCacheSize()
    {
      return self()->mIconCacheSize;
    }

    /**
      Is Icon Cache Size Immutable
    */
    static
    bool isIconCacheSizeImmutable()
    {
      return self()->isImmutable( QStringLiteral( "IconCacheSize" ) );
    }

    /**
      Set Image Cache Size
    */
    static
    void setImageCacheSize( quint64 v )
    {
      if (!self()->isImageCacheSizeImmutable())
        self()->mImageCacheSize = v;
    }

    /**
      Get Image Cache Size
    */
    static
    quint64 imageCacheSize()
    {
      return self()->mImageCacheSize;
    }

    /**
      Is Image Cache Size Immutable
    */
    static
    bool isImageCacheSizeImmutable()
    {
      return self()->isImmutable( QStringLiteral( "ImageCacheSize" ) );
    }

    /**
      Set Max Custom URL Settings
    */
    static
    void setMaxCustomURLSettings( int v )
    {
      if (!self()->isMaxCustomURLSettingsImmutable())
        self()->mMaxCustomURLSettings = v;
    }

    /**
      Get Max Custom URL Settings
    */
    static
    int maxCustomURLSettings()
    {
      return self()->mMaxCustomURLSettings;
    }

    /**
      Is Max Custom URL Settings Immutable
    */
    static
    bool isMaxCustomURLSettingsImmutable()
    {
      return self()->isImmutable( QStringLiteral( "MaxCustomURLSettings" ) );
    }

    /**
      Set Enable Webcam
    */
    static
    void setEnableWebcam( bool v )
    {
      if (!self()->isEnableWebcamImmutable())
        self()->mEnableWebcam = v;
    }

    /**
      Get Enable Webcam
    */
    static
    bool enableWebcam()
    {
      return self()->mEnableWebcam;
    }

    /**
      Is Enable Webcam Immutable
    */
    static
    bool isEnableWebcamImmutable()
    {
      return self()->isImmutable( QStringLiteral( "EnableWebcam" ) );
    }

    /**
      Set Quick Filter RegExp
    */
    static
    void setQuickFilterRegExp( bool v )
    {
      if (!self()->isQuickFilterRegExpImmutable())
        self()->mQuickFilterRegExp = v;
    }

    /**
      Get Quick Filter RegExp
    */
    static
    bool quickFilterRegExp()
    {
      return self()->mQuickFilterRegExp;
    }

    /**
      Is Quick Filter RegExp Immutable
    */
    static
    bool isQuickFilterRegExpImmutable()
    {
      return self()->isImmutable( QStringLiteral( "QuickFilterRegExp" ) );
    }

    /**
      Set Show Welcome
    */
    static
    void setShowWelcome( bool v )
    {
      if (!self()->isShowWelcomeImmutable())
        self()->mShowWelcome = v;
    }

    /**
      Get Show Welcome
    */
    static
    bool showWelcome()
    {
      return self()->mShowWelcome;
    }

    /**
      Is Show Welcome Immutable
    */
    static
    bool isShowWelcomeImmutable()
    {
      return self()->isImmutable( QStringLiteral( "ShowWelcome" ) );
    }

    /**
      Set Print Field Headers
    */
    static
    void setPrintFieldHeaders( bool v )
    {
      if (!self()->isPrintFieldHeadersImmutable())
        self()->mPrintFieldHeaders = v;
    }

    /**
      Get Print Field Headers
    */
    static
    bool printFieldHeaders()
    {
      return self()->mPrintFieldHeaders;
    }

    /**
      Is Print Field Headers Immutable
    */
    static
    bool isPrintFieldHeadersImmutable()
    {
      return self()->isImmutable( QStringLiteral( "PrintFieldHeaders" ) );
    }

    /**
      Set Print Formatted
    */
    static
    void setPrintFormatted( bool v )
    {
      if (!self()->isPrintFormattedImmutable())
        self()->mPrintFormatted = v;
    }

    /**
      Get Print Formatted
    */
    static
    bool printFormatted()
    {
      return self()->mPrintFormatted;
    }

    /**
      Is Print Formatted Immutable
    */
    static
    bool isPrintFormattedImmutable()
    {
      return self()->isImmutable( QStringLiteral( "PrintFormatted" ) );
    }

    /**
      Set Print Grouped
    */
    static
    void setPrintGrouped( bool v )
    {
      if (!self()->isPrintGroupedImmutable())
        self()->mPrintGrouped = v;
    }

    /**
      Get Print Grouped
    */
    static
    bool printGrouped()
    {
      return self()->mPrintGrouped;
    }

    /**
      Is Print Grouped Immutable
    */
    static
    bool isPrintGroupedImmutable()
    {
      return self()->isImmutable( QStringLiteral( "PrintGrouped" ) );
    }

    /**
      Set Max Image Width
    */
    static
    void setMaxImageWidth( int v )
    {
      if (!self()->isMaxImageWidthImmutable())
        self()->mMaxImageWidth = v;
    }

    /**
      Get Max Image Width
    */
    static
    int maxImageWidth()
    {
      return self()->mMaxImageWidth;
    }

    /**
      Is Max Image Width Immutable
    */
    static
    bool isMaxImageWidthImmutable()
    {
      return self()->isImmutable( QStringLiteral( "MaxImageWidth" ) );
    }

    /**
      Set Max Image Height
    */
    static
    void setMaxImageHeight( int v )
    {
      if (!self()->isMaxImageHeightImmutable())
        self()->mMaxImageHeight = v;
    }

    /**
      Get Max Image Height
    */
    static
    int maxImageHeight()
    {
      return self()->mMaxImageHeight;
    }

    /**
      Is Max Image Height Immutable
    */
    static
    bool isMaxImageHeightImmutable()
    {
      return self()->isImmutable( QStringLiteral( "MaxImageHeight" ) );
    }

    /**
      Set Entry Template
    */
    static
    void setTemplateBook( const QString & v )
    {
      if (!self()->isTemplateBookImmutable())
        self()->mTemplateBook = v;
    }

    /**
      Get Entry Template
    */
    static
    QString templateBook()
    {
      return self()->mTemplateBook;
    }

    /**
      Is Entry Template Immutable
    */
    static
    bool isTemplateBookImmutable()
    {
      return self()->isImmutable( QStringLiteral( "templateBook" ) );
    }

    /**
      Set Template font
    */
    static
    void setFontBook( const QFont & v )
    {
      if (!self()->isFontBookImmutable())
        self()->mFontBook = v;
    }

    /**
      Get Template font
    */
    static
    QFont fontBook()
    {
      return self()->mFontBook;
    }

    /**
      Is Template font Immutable
    */
    static
    bool isFontBookImmutable()
    {
      return self()->isImmutable( QStringLiteral( "fontBook" ) );
    }

    /**
      Set Template background color
    */
    static
    void setBaseColorBook( const QColor & v )
    {
      if (!self()->isBaseColorBookImmutable())
        self()->mBaseColorBook = v;
    }

    /**
      Get Template background color
    */
    static
    QColor baseColorBook()
    {
      return self()->mBaseColorBook;
    }

    /**
      Is Template background color Immutable
    */
    static
    bool isBaseColorBookImmutable()
    {
      return self()->isImmutable( QStringLiteral( "baseColorBook" ) );
    }

    /**
      Set Template text color
    */
    static
    void setTextColorBook( const QColor & v )
    {
      if (!self()->isTextColorBookImmutable())
        self()->mTextColorBook = v;
    }

    /**
      Get Template text color
    */
    static
    QColor textColorBook()
    {
      return self()->mTextColorBook;
    }

    /**
      Is Template text color Immutable
    */
    static
    bool isTextColorBookImmutable()
    {
      return self()->isImmutable( QStringLiteral( "textColorBook" ) );
    }

    /**
      Set Template highlight color
    */
    static
    void setHighlightedBaseColorBook( const QColor & v )
    {
      if (!self()->isHighlightedBaseColorBookImmutable())
        self()->mHighlightedBaseColorBook = v;
    }

    /**
      Get Template highlight color
    */
    static
    QColor highlightedBaseColorBook()
    {
      return self()->mHighlightedBaseColorBook;
    }

    /**
      Is Template highlight color Immutable
    */
    static
    bool isHighlightedBaseColorBookImmutable()
    {
      return self()->isImmutable( QStringLiteral( "highlightedBaseColorBook" ) );
    }

    /**
      Set Template highlighted text color
    */
    static
    void setHighlightedTextColorBook( const QColor & v )
    {
      if (!self()->isHighlightedTextColorBookImmutable())
        self()->mHighlightedTextColorBook = v;
    }

    /**
      Get Template highlighted text color
    */
    static
    QColor highlightedTextColorBook()
    {
      return self()->mHighlightedTextColorBook;
    }

    /**
      Is Template highlighted text color Immutable
    */
    static
    bool isHighlightedTextColorBookImmutable()
    {
      return self()->isImmutable( QStringLiteral( "highlightedTextColorBook" ) );
    }

    /**
      Set Template link color
    */
    static
    void setLinkColorBook( const QColor & v )
    {
      if (!self()->isLinkColorBookImmutable())
        self()->mLinkColorBook = v;
    }

    /**
      Get Template link color
    */
    static
    QColor linkColorBook()
    {
      return self()->mLinkColorBook;
    }

    /**
      Is Template link color Immutable
    */
    static
    bool isLinkColorBookImmutable()
    {
      return self()->isImmutable( QStringLiteral( "linkColorBook" ) );
    }

    /**
      Set Entry Template
    */
    static
    void setTemplateVideo( const QString & v )
    {
      if (!self()->isTemplateVideoImmutable())
        self()->mTemplateVideo = v;
    }

    /**
      Get Entry Template
    */
    static
    QString templateVideo()
    {
      return self()->mTemplateVideo;
    }

    /**
      Is Entry Template Immutable
    */
    static
    bool isTemplateVideoImmutable()
    {
      return self()->isImmutable( QStringLiteral( "templateVideo" ) );
    }

    /**
      Set Template font
    */
    static
    void setFontVideo( const QFont & v )
    {
      if (!self()->isFontVideoImmutable())
        self()->mFontVideo = v;
    }

    /**
      Get Template font
    */
    static
    QFont fontVideo()
    {
      return self()->mFontVideo;
    }

    /**
      Is Template font Immutable
    */
    static
    bool isFontVideoImmutable()
    {
      return self()->isImmutable( QStringLiteral( "fontVideo" ) );
    }

    /**
      Set Template background color
    */
    static
    void setBaseColorVideo( const QColor & v )
    {
      if (!self()->isBaseColorVideoImmutable())
        self()->mBaseColorVideo = v;
    }

    /**
      Get Template background color
    */
    static
    QColor baseColorVideo()
    {
      return self()->mBaseColorVideo;
    }

    /**
      Is Template background color Immutable
    */
    static
    bool isBaseColorVideoImmutable()
    {
      return self()->isImmutable( QStringLiteral( "baseColorVideo" ) );
    }

    /**
      Set Template text color
    */
    static
    void setTextColorVideo( const QColor & v )
    {
      if (!self()->isTextColorVideoImmutable())
        self()->mTextColorVideo = v;
    }

    /**
      Get Template text color
    */
    static
    QColor textColorVideo()
    {
      return self()->mTextColorVideo;
    }

    /**
      Is Template text color Immutable
    */
    static
    bool isTextColorVideoImmutable()
    {
      return self()->isImmutable( QStringLiteral( "textColorVideo" ) );
    }

    /**
      Set Template highlight color
    */
    static
    void setHighlightedBaseColorVideo( const QColor & v )
    {
      if (!self()->isHighlightedBaseColorVideoImmutable())
        self()->mHighlightedBaseColorVideo = v;
    }

    /**
      Get Template highlight color
    */
    static
    QColor highlightedBaseColorVideo()
    {
      return self()->mHighlightedBaseColorVideo;
    }

    /**
      Is Template highlight color Immutable
    */
    static
    bool isHighlightedBaseColorVideoImmutable()
    {
      return self()->isImmutable( QStringLiteral( "highlightedBaseColorVideo" ) );
    }

    /**
      Set Template highlighted text color
    */
    static
    void setHighlightedTextColorVideo( const QColor & v )
    {
      if (!self()->isHighlightedTextColorVideoImmutable())
        self()->mHighlightedTextColorVideo = v;
    }

    /**
      Get Template highlighted text color
    */
    static
    QColor highlightedTextColorVideo()
    {
      return self()->mHighlightedTextColorVideo;
    }

    /**
      Is Template highlighted text color Immutable
    */
    static
    bool isHighlightedTextColorVideoImmutable()
    {
      return self()->isImmutable( QStringLiteral( "highlightedTextColorVideo" ) );
    }

    /**
      Set Template link color
    */
    static
    void setLinkColorVideo( const QColor & v )
    {
      if (!self()->isLinkColorVideoImmutable())
        self()->mLinkColorVideo = v;
    }

    /**
      Get Template link color
    */
    static
    QColor linkColorVideo()
    {
      return self()->mLinkColorVideo;
    }

    /**
      Is Template link color Immutable
    */
    static
    bool isLinkColorVideoImmutable()
    {
      return self()->isImmutable( QStringLiteral( "linkColorVideo" ) );
    }

    /**
      Set Entry Template
    */
    static
    void setTemplateAlbum( const QString & v )
    {
      if (!self()->isTemplateAlbumImmutable())
        self()->mTemplateAlbum = v;
    }

    /**
      Get Entry Template
    */
    static
    QString templateAlbum()
    {
      return self()->mTemplateAlbum;
    }

    /**
      Is Entry Template Immutable
    */
    static
    bool isTemplateAlbumImmutable()
    {
      return self()->isImmutable( QStringLiteral( "templateAlbum" ) );
    }

    /**
      Set Template font
    */
    static
    void setFontAlbum( const QFont & v )
    {
      if (!self()->isFontAlbumImmutable())
        self()->mFontAlbum = v;
    }

    /**
      Get Template font
    */
    static
    QFont fontAlbum()
    {
      return self()->mFontAlbum;
    }

    /**
      Is Template font Immutable
    */
    static
    bool isFontAlbumImmutable()
    {
      return self()->isImmutable( QStringLiteral( "fontAlbum" ) );
    }

    /**
      Set Template background color
    */
    static
    void setBaseColorAlbum( const QColor & v )
    {
      if (!self()->isBaseColorAlbumImmutable())
        self()->mBaseColorAlbum = v;
    }

    /**
      Get Template background color
    */
    static
    QColor baseColorAlbum()
    {
      return self()->mBaseColorAlbum;
    }

    /**
      Is Template background color Immutable
    */
    static
    bool isBaseColorAlbumImmutable()
    {
      return self()->isImmutable( QStringLiteral( "baseColorAlbum" ) );
    }

    /**
      Set Template text color
    */
    static
    void setTextColorAlbum( const QColor & v )
    {
      if (!self()->isTextColorAlbumImmutable())
        self()->mTextColorAlbum = v;
    }

    /**
      Get Template text color
    */
    static
    QColor textColorAlbum()
    {
      return self()->mTextColorAlbum;
    }

    /**
      Is Template text color Immutable
    */
    static
    bool isTextColorAlbumImmutable()
    {
      return self()->isImmutable( QStringLiteral( "textColorAlbum" ) );
    }

    /**
      Set Template highlight color
    */
    static
    void setHighlightedBaseColorAlbum( const QColor & v )
    {
      if (!self()->isHighlightedBaseColorAlbumImmutable())
        self()->mHighlightedBaseColorAlbum = v;
    }

    /**
      Get Template highlight color
    */
    static
    QColor highlightedBaseColorAlbum()
    {
      return self()->mHighlightedBaseColorAlbum;
    }

    /**
      Is Template highlight color Immutable
    */
    static
    bool isHighlightedBaseColorAlbumImmutable()
    {
      return self()->isImmutable( QStringLiteral( "highlightedBaseColorAlbum" ) );
    }

    /**
      Set Template highlighted text color
    */
    static
    void setHighlightedTextColorAlbum( const QColor & v )
    {
      if (!self()->isHighlightedTextColorAlbumImmutable())
        self()->mHighlightedTextColorAlbum = v;
    }

    /**
      Get Template highlighted text color
    */
    static
    QColor highlightedTextColorAlbum()
    {
      return self()->mHighlightedTextColorAlbum;
    }

    /**
      Is Template highlighted text color Immutable
    */
    static
    bool isHighlightedTextColorAlbumImmutable()
    {
      return self()->isImmutable( QStringLiteral( "highlightedTextColorAlbum" ) );
    }

    /**
      Set Template link color
    */
    static
    void setLinkColorAlbum( const QColor & v )
    {
      if (!self()->isLinkColorAlbumImmutable())
        self()->mLinkColorAlbum = v;
    }

    /**
      Get Template link color
    */
    static
    QColor linkColorAlbum()
    {
      return self()->mLinkColorAlbum;
    }

    /**
      Is Template link color Immutable
    */
    static
    bool isLinkColorAlbumImmutable()
    {
      return self()->isImmutable( QStringLiteral( "linkColorAlbum" ) );
    }

    /**
      Set lyxpipe
    */
    static
    void setLyxpipe( const QString & v )
    {
      if (!self()->isLyxpipeImmutable())
        self()->mLyxpipe = v;
    }

    /**
      Get lyxpipe
    */
    static
    QString lyxpipe()
    {
      return self()->mLyxpipe;
    }

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

    /**
      Set Entry Template
    */
    static
    void setTemplateBibtex( const QString & v )
    {
      if (!self()->isTemplateBibtexImmutable())
        self()->mTemplateBibtex = v;
    }

    /**
      Get Entry Template
    */
    static
    QString templateBibtex()
    {
      return self()->mTemplateBibtex;
    }

    /**
      Is Entry Template Immutable
    */
    static
    bool isTemplateBibtexImmutable()
    {
      return self()->isImmutable( QStringLiteral( "templateBibtex" ) );
    }

    /**
      Set Template font
    */
    static
    void setFontBibtex( const QFont & v )
    {
      if (!self()->isFontBibtexImmutable())
        self()->mFontBibtex = v;
    }

    /**
      Get Template font
    */
    static
    QFont fontBibtex()
    {
      return self()->mFontBibtex;
    }

    /**
      Is Template font Immutable
    */
    static
    bool isFontBibtexImmutable()
    {
      return self()->isImmutable( QStringLiteral( "fontBibtex" ) );
    }

    /**
      Set Template background color
    */
    static
    void setBaseColorBibtex( const QColor & v )
    {
      if (!self()->isBaseColorBibtexImmutable())
        self()->mBaseColorBibtex = v;
    }

    /**
      Get Template background color
    */
    static
    QColor baseColorBibtex()
    {
      return self()->mBaseColorBibtex;
    }

    /**
      Is Template background color Immutable
    */
    static
    bool isBaseColorBibtexImmutable()
    {
      return self()->isImmutable( QStringLiteral( "baseColorBibtex" ) );
    }

    /**
      Set Template text color
    */
    static
    void setTextColorBibtex( const QColor & v )
    {
      if (!self()->isTextColorBibtexImmutable())
        self()->mTextColorBibtex = v;
    }

    /**
      Get Template text color
    */
    static
    QColor textColorBibtex()
    {
      return self()->mTextColorBibtex;
    }

    /**
      Is Template text color Immutable
    */
    static
    bool isTextColorBibtexImmutable()
    {
      return self()->isImmutable( QStringLiteral( "textColorBibtex" ) );
    }

    /**
      Set Template highlight color
    */
    static
    void setHighlightedBaseColorBibtex( const QColor & v )
    {
      if (!self()->isHighlightedBaseColorBibtexImmutable())
        self()->mHighlightedBaseColorBibtex = v;
    }

    /**
      Get Template highlight color
    */
    static
    QColor highlightedBaseColorBibtex()
    {
      return self()->mHighlightedBaseColorBibtex;
    }

    /**
      Is Template highlight color Immutable
    */
    static
    bool isHighlightedBaseColorBibtexImmutable()
    {
      return self()->isImmutable( QStringLiteral( "highlightedBaseColorBibtex" ) );
    }

    /**
      Set Template highlighted text color
    */
    static
    void setHighlightedTextColorBibtex( const QColor & v )
    {
      if (!self()->isHighlightedTextColorBibtexImmutable())
        self()->mHighlightedTextColorBibtex = v;
    }

    /**
      Get Template highlighted text color
    */
    static
    QColor highlightedTextColorBibtex()
    {
      return self()->mHighlightedTextColorBibtex;
    }

    /**
      Is Template highlighted text color Immutable
    */
    static
    bool isHighlightedTextColorBibtexImmutable()
    {
      return self()->isImmutable( QStringLiteral( "highlightedTextColorBibtex" ) );
    }

    /**
      Set Template link color
    */
    static
    void setLinkColorBibtex( const QColor & v )
    {
      if (!self()->isLinkColorBibtexImmutable())
        self()->mLinkColorBibtex = v;
    }

    /**
      Get Template link color
    */
    static
    QColor linkColorBibtex()
    {
      return self()->mLinkColorBibtex;
    }

    /**
      Is Template link color Immutable
    */
    static
    bool isLinkColorBibtexImmutable()
    {
      return self()->isImmutable( QStringLiteral( "linkColorBibtex" ) );
    }

    /**
      Set Entry Template
    */
    static
    void setTemplateComicBook( const QString & v )
    {
      if (!self()->isTemplateComicBookImmutable())
        self()->mTemplateComicBook = v;
    }

    /**
      Get Entry Template
    */
    static
    QString templateComicBook()
    {
      return self()->mTemplateComicBook;
    }

    /**
      Is Entry Template Immutable
    */
    static
    bool isTemplateComicBookImmutable()
    {
      return self()->isImmutable( QStringLiteral( "templateComicBook" ) );
    }

    /**
      Set Template font
    */
    static
    void setFontComicBook( const QFont & v )
    {
      if (!self()->isFontComicBookImmutable())
        self()->mFontComicBook = v;
    }

    /**
      Get Template font
    */
    static
    QFont fontComicBook()
    {
      return self()->mFontComicBook;
    }

    /**
      Is Template font Immutable
    */
    static
    bool isFontComicBookImmutable()
    {
      return self()->isImmutable( QStringLiteral( "fontComicBook" ) );
    }

    /**
      Set Template background color
    */
    static
    void setBaseColorComicBook( const QColor & v )
    {
      if (!self()->isBaseColorComicBookImmutable())
        self()->mBaseColorComicBook = v;
    }

    /**
      Get Template background color
    */
    static
    QColor baseColorComicBook()
    {
      return self()->mBaseColorComicBook;
    }

    /**
      Is Template background color Immutable
    */
    static
    bool isBaseColorComicBookImmutable()
    {
      return self()->isImmutable( QStringLiteral( "baseColorComicBook" ) );
    }

    /**
      Set Template text color
    */
    static
    void setTextColorComicBook( const QColor & v )
    {
      if (!self()->isTextColorComicBookImmutable())
        self()->mTextColorComicBook = v;
    }

    /**
      Get Template text color
    */
    static
    QColor textColorComicBook()
    {
      return self()->mTextColorComicBook;
    }

    /**
      Is Template text color Immutable
    */
    static
    bool isTextColorComicBookImmutable()
    {
      return self()->isImmutable( QStringLiteral( "textColorComicBook" ) );
    }

    /**
      Set Template highlight color
    */
    static
    void setHighlightedBaseColorComicBook( const QColor & v )
    {
      if (!self()->isHighlightedBaseColorComicBookImmutable())
        self()->mHighlightedBaseColorComicBook = v;
    }

    /**
      Get Template highlight color
    */
    static
    QColor highlightedBaseColorComicBook()
    {
      return self()->mHighlightedBaseColorComicBook;
    }

    /**
      Is Template highlight color Immutable
    */
    static
    bool isHighlightedBaseColorComicBookImmutable()
    {
      return self()->isImmutable( QStringLiteral( "highlightedBaseColorComicBook" ) );
    }

    /**
      Set Template highlighted text color
    */
    static
    void setHighlightedTextColorComicBook( const QColor & v )
    {
      if (!self()->isHighlightedTextColorComicBookImmutable())
        self()->mHighlightedTextColorComicBook = v;
    }

    /**
      Get Template highlighted text color
    */
    static
    QColor highlightedTextColorComicBook()
    {
      return self()->mHighlightedTextColorComicBook;
    }

    /**
      Is Template highlighted text color Immutable
    */
    static
    bool isHighlightedTextColorComicBookImmutable()
    {
      return self()->isImmutable( QStringLiteral( "highlightedTextColorComicBook" ) );
    }

    /**
      Set Template link color
    */
    static
    void setLinkColorComicBook( const QColor & v )
    {
      if (!self()->isLinkColorComicBookImmutable())
        self()->mLinkColorComicBook = v;
    }

    /**
      Get Template link color
    */
    static
    QColor linkColorComicBook()
    {
      return self()->mLinkColorComicBook;
    }

    /**
      Is Template link color Immutable
    */
    static
    bool isLinkColorComicBookImmutable()
    {
      return self()->isImmutable( QStringLiteral( "linkColorComicBook" ) );
    }

    /**
      Set Entry Template
    */
    static
    void setTemplateWine( const QString & v )
    {
      if (!self()->isTemplateWineImmutable())
        self()->mTemplateWine = v;
    }

    /**
      Get Entry Template
    */
    static
    QString templateWine()
    {
      return self()->mTemplateWine;
    }

    /**
      Is Entry Template Immutable
    */
    static
    bool isTemplateWineImmutable()
    {
      return self()->isImmutable( QStringLiteral( "templateWine" ) );
    }

    /**
      Set Template font
    */
    static
    void setFontWine( const QFont & v )
    {
      if (!self()->isFontWineImmutable())
        self()->mFontWine = v;
    }

    /**
      Get Template font
    */
    static
    QFont fontWine()
    {
      return self()->mFontWine;
    }

    /**
      Is Template font Immutable
    */
    static
    bool isFontWineImmutable()
    {
      return self()->isImmutable( QStringLiteral( "fontWine" ) );
    }

    /**
      Set Template background color
    */
    static
    void setBaseColorWine( const QColor & v )
    {
      if (!self()->isBaseColorWineImmutable())
        self()->mBaseColorWine = v;
    }

    /**
      Get Template background color
    */
    static
    QColor baseColorWine()
    {
      return self()->mBaseColorWine;
    }

    /**
      Is Template background color Immutable
    */
    static
    bool isBaseColorWineImmutable()
    {
      return self()->isImmutable( QStringLiteral( "baseColorWine" ) );
    }

    /**
      Set Template text color
    */
    static
    void setTextColorWine( const QColor & v )
    {
      if (!self()->isTextColorWineImmutable())
        self()->mTextColorWine = v;
    }

    /**
      Get Template text color
    */
    static
    QColor textColorWine()
    {
      return self()->mTextColorWine;
    }

    /**
      Is Template text color Immutable
    */
    static
    bool isTextColorWineImmutable()
    {
      return self()->isImmutable( QStringLiteral( "textColorWine" ) );
    }

    /**
      Set Template highlight color
    */
    static
    void setHighlightedBaseColorWine( const QColor & v )
    {
      if (!self()->isHighlightedBaseColorWineImmutable())
        self()->mHighlightedBaseColorWine = v;
    }

    /**
      Get Template highlight color
    */
    static
    QColor highlightedBaseColorWine()
    {
      return self()->mHighlightedBaseColorWine;
    }

    /**
      Is Template highlight color Immutable
    */
    static
    bool isHighlightedBaseColorWineImmutable()
    {
      return self()->isImmutable( QStringLiteral( "highlightedBaseColorWine" ) );
    }

    /**
      Set Template highlighted text color
    */
    static
    void setHighlightedTextColorWine( const QColor & v )
    {
      if (!self()->isHighlightedTextColorWineImmutable())
        self()->mHighlightedTextColorWine = v;
    }

    /**
      Get Template highlighted text color
    */
    static
    QColor highlightedTextColorWine()
    {
      return self()->mHighlightedTextColorWine;
    }

    /**
      Is Template highlighted text color Immutable
    */
    static
    bool isHighlightedTextColorWineImmutable()
    {
      return self()->isImmutable( QStringLiteral( "highlightedTextColorWine" ) );
    }

    /**
      Set Template link color
    */
    static
    void setLinkColorWine( const QColor & v )
    {
      if (!self()->isLinkColorWineImmutable())
        self()->mLinkColorWine = v;
    }

    /**
      Get Template link color
    */
    static
    QColor linkColorWine()
    {
      return self()->mLinkColorWine;
    }

    /**
      Is Template link color Immutable
    */
    static
    bool isLinkColorWineImmutable()
    {
      return self()->isImmutable( QStringLiteral( "linkColorWine" ) );
    }

    /**
      Set Entry Template
    */
    static
    void setTemplateCoin( const QString & v )
    {
      if (!self()->isTemplateCoinImmutable())
        self()->mTemplateCoin = v;
    }

    /**
      Get Entry Template
    */
    static
    QString templateCoin()
    {
      return self()->mTemplateCoin;
    }

    /**
      Is Entry Template Immutable
    */
    static
    bool isTemplateCoinImmutable()
    {
      return self()->isImmutable( QStringLiteral( "templateCoin" ) );
    }

    /**
      Set Template font
    */
    static
    void setFontCoin( const QFont & v )
    {
      if (!self()->isFontCoinImmutable())
        self()->mFontCoin = v;
    }

    /**
      Get Template font
    */
    static
    QFont fontCoin()
    {
      return self()->mFontCoin;
    }

    /**
      Is Template font Immutable
    */
    static
    bool isFontCoinImmutable()
    {
      return self()->isImmutable( QStringLiteral( "fontCoin" ) );
    }

    /**
      Set Template background color
    */
    static
    void setBaseColorCoin( const QColor & v )
    {
      if (!self()->isBaseColorCoinImmutable())
        self()->mBaseColorCoin = v;
    }

    /**
      Get Template background color
    */
    static
    QColor baseColorCoin()
    {
      return self()->mBaseColorCoin;
    }

    /**
      Is Template background color Immutable
    */
    static
    bool isBaseColorCoinImmutable()
    {
      return self()->isImmutable( QStringLiteral( "baseColorCoin" ) );
    }

    /**
      Set Template text color
    */
    static
    void setTextColorCoin( const QColor & v )
    {
      if (!self()->isTextColorCoinImmutable())
        self()->mTextColorCoin = v;
    }

    /**
      Get Template text color
    */
    static
    QColor textColorCoin()
    {
      return self()->mTextColorCoin;
    }

    /**
      Is Template text color Immutable
    */
    static
    bool isTextColorCoinImmutable()
    {
      return self()->isImmutable( QStringLiteral( "textColorCoin" ) );
    }

    /**
      Set Template highlight color
    */
    static
    void setHighlightedBaseColorCoin( const QColor & v )
    {
      if (!self()->isHighlightedBaseColorCoinImmutable())
        self()->mHighlightedBaseColorCoin = v;
    }

    /**
      Get Template highlight color
    */
    static
    QColor highlightedBaseColorCoin()
    {
      return self()->mHighlightedBaseColorCoin;
    }

    /**
      Is Template highlight color Immutable
    */
    static
    bool isHighlightedBaseColorCoinImmutable()
    {
      return self()->isImmutable( QStringLiteral( "highlightedBaseColorCoin" ) );
    }

    /**
      Set Template highlighted text color
    */
    static
    void setHighlightedTextColorCoin( const QColor & v )
    {
      if (!self()->isHighlightedTextColorCoinImmutable())
        self()->mHighlightedTextColorCoin = v;
    }

    /**
      Get Template highlighted text color
    */
    static
    QColor highlightedTextColorCoin()
    {
      return self()->mHighlightedTextColorCoin;
    }

    /**
      Is Template highlighted text color Immutable
    */
    static
    bool isHighlightedTextColorCoinImmutable()
    {
      return self()->isImmutable( QStringLiteral( "highlightedTextColorCoin" ) );
    }

    /**
      Set Template link color
    */
    static
    void setLinkColorCoin( const QColor & v )
    {
      if (!self()->isLinkColorCoinImmutable())
        self()->mLinkColorCoin = v;
    }

    /**
      Get Template link color
    */
    static
    QColor linkColorCoin()
    {
      return self()->mLinkColorCoin;
    }

    /**
      Is Template link color Immutable
    */
    static
    bool isLinkColorCoinImmutable()
    {
      return self()->isImmutable( QStringLiteral( "linkColorCoin" ) );
    }

    /**
      Set Entry Template
    */
    static
    void setTemplateStamp( const QString & v )
    {
      if (!self()->isTemplateStampImmutable())
        self()->mTemplateStamp = v;
    }

    /**
      Get Entry Template
    */
    static
    QString templateStamp()
    {
      return self()->mTemplateStamp;
    }

    /**
      Is Entry Template Immutable
    */
    static
    bool isTemplateStampImmutable()
    {
      return self()->isImmutable( QStringLiteral( "templateStamp" ) );
    }

    /**
      Set Template font
    */
    static
    void setFontStamp( const QFont & v )
    {
      if (!self()->isFontStampImmutable())
        self()->mFontStamp = v;
    }

    /**
      Get Template font
    */
    static
    QFont fontStamp()
    {
      return self()->mFontStamp;
    }

    /**
      Is Template font Immutable
    */
    static
    bool isFontStampImmutable()
    {
      return self()->isImmutable( QStringLiteral( "fontStamp" ) );
    }

    /**
      Set Template background color
    */
    static
    void setBaseColorStamp( const QColor & v )
    {
      if (!self()->isBaseColorStampImmutable())
        self()->mBaseColorStamp = v;
    }

    /**
      Get Template background color
    */
    static
    QColor baseColorStamp()
    {
      return self()->mBaseColorStamp;
    }

    /**
      Is Template background color Immutable
    */
    static
    bool isBaseColorStampImmutable()
    {
      return self()->isImmutable( QStringLiteral( "baseColorStamp" ) );
    }

    /**
      Set Template text color
    */
    static
    void setTextColorStamp( const QColor & v )
    {
      if (!self()->isTextColorStampImmutable())
        self()->mTextColorStamp = v;
    }

    /**
      Get Template text color
    */
    static
    QColor textColorStamp()
    {
      return self()->mTextColorStamp;
    }

    /**
      Is Template text color Immutable
    */
    static
    bool isTextColorStampImmutable()
    {
      return self()->isImmutable( QStringLiteral( "textColorStamp" ) );
    }

    /**
      Set Template highlight color
    */
    static
    void setHighlightedBaseColorStamp( const QColor & v )
    {
      if (!self()->isHighlightedBaseColorStampImmutable())
        self()->mHighlightedBaseColorStamp = v;
    }

    /**
      Get Template highlight color
    */
    static
    QColor highlightedBaseColorStamp()
    {
      return self()->mHighlightedBaseColorStamp;
    }

    /**
      Is Template highlight color Immutable
    */
    static
    bool isHighlightedBaseColorStampImmutable()
    {
      return self()->isImmutable( QStringLiteral( "highlightedBaseColorStamp" ) );
    }

    /**
      Set Template highlighted text color
    */
    static
    void setHighlightedTextColorStamp( const QColor & v )
    {
      if (!self()->isHighlightedTextColorStampImmutable())
        self()->mHighlightedTextColorStamp = v;
    }

    /**
      Get Template highlighted text color
    */
    static
    QColor highlightedTextColorStamp()
    {
      return self()->mHighlightedTextColorStamp;
    }

    /**
      Is Template highlighted text color Immutable
    */
    static
    bool isHighlightedTextColorStampImmutable()
    {
      return self()->isImmutable( QStringLiteral( "highlightedTextColorStamp" ) );
    }

    /**
      Set Template link color
    */
    static
    void setLinkColorStamp( const QColor & v )
    {
      if (!self()->isLinkColorStampImmutable())
        self()->mLinkColorStamp = v;
    }

    /**
      Get Template link color
    */
    static
    QColor linkColorStamp()
    {
      return self()->mLinkColorStamp;
    }

    /**
      Is Template link color Immutable
    */
    static
    bool isLinkColorStampImmutable()
    {
      return self()->isImmutable( QStringLiteral( "linkColorStamp" ) );
    }

    /**
      Set Entry Template
    */
    static
    void setTemplateCard( const QString & v )
    {
      if (!self()->isTemplateCardImmutable())
        self()->mTemplateCard = v;
    }

    /**
      Get Entry Template
    */
    static
    QString templateCard()
    {
      return self()->mTemplateCard;
    }

    /**
      Is Entry Template Immutable
    */
    static
    bool isTemplateCardImmutable()
    {
      return self()->isImmutable( QStringLiteral( "templateCard" ) );
    }

    /**
      Set Template font
    */
    static
    void setFontCard( const QFont & v )
    {
      if (!self()->isFontCardImmutable())
        self()->mFontCard = v;
    }

    /**
      Get Template font
    */
    static
    QFont fontCard()
    {
      return self()->mFontCard;
    }

    /**
      Is Template font Immutable
    */
    static
    bool isFontCardImmutable()
    {
      return self()->isImmutable( QStringLiteral( "fontCard" ) );
    }

    /**
      Set Template background color
    */
    static
    void setBaseColorCard( const QColor & v )
    {
      if (!self()->isBaseColorCardImmutable())
        self()->mBaseColorCard = v;
    }

    /**
      Get Template background color
    */
    static
    QColor baseColorCard()
    {
      return self()->mBaseColorCard;
    }

    /**
      Is Template background color Immutable
    */
    static
    bool isBaseColorCardImmutable()
    {
      return self()->isImmutable( QStringLiteral( "baseColorCard" ) );
    }

    /**
      Set Template text color
    */
    static
    void setTextColorCard( const QColor & v )
    {
      if (!self()->isTextColorCardImmutable())
        self()->mTextColorCard = v;
    }

    /**
      Get Template text color
    */
    static
    QColor textColorCard()
    {
      return self()->mTextColorCard;
    }

    /**
      Is Template text color Immutable
    */
    static
    bool isTextColorCardImmutable()
    {
      return self()->isImmutable( QStringLiteral( "textColorCard" ) );
    }

    /**
      Set Template highlight color
    */
    static
    void setHighlightedBaseColorCard( const QColor & v )
    {
      if (!self()->isHighlightedBaseColorCardImmutable())
        self()->mHighlightedBaseColorCard = v;
    }

    /**
      Get Template highlight color
    */
    static
    QColor highlightedBaseColorCard()
    {
      return self()->mHighlightedBaseColorCard;
    }

    /**
      Is Template highlight color Immutable
    */
    static
    bool isHighlightedBaseColorCardImmutable()
    {
      return self()->isImmutable( QStringLiteral( "highlightedBaseColorCard" ) );
    }

    /**
      Set Template highlighted text color
    */
    static
    void setHighlightedTextColorCard( const QColor & v )
    {
      if (!self()->isHighlightedTextColorCardImmutable())
        self()->mHighlightedTextColorCard = v;
    }

    /**
      Get Template highlighted text color
    */
    static
    QColor highlightedTextColorCard()
    {
      return self()->mHighlightedTextColorCard;
    }

    /**
      Is Template highlighted text color Immutable
    */
    static
    bool isHighlightedTextColorCardImmutable()
    {
      return self()->isImmutable( QStringLiteral( "highlightedTextColorCard" ) );
    }

    /**
      Set Template link color
    */
    static
    void setLinkColorCard( const QColor & v )
    {
      if (!self()->isLinkColorCardImmutable())
        self()->mLinkColorCard = v;
    }

    /**
      Get Template link color
    */
    static
    QColor linkColorCard()
    {
      return self()->mLinkColorCard;
    }

    /**
      Is Template link color Immutable
    */
    static
    bool isLinkColorCardImmutable()
    {
      return self()->isImmutable( QStringLiteral( "linkColorCard" ) );
    }

    /**
      Set Entry Template
    */
    static
    void setTemplateGame( const QString & v )
    {
      if (!self()->isTemplateGameImmutable())
        self()->mTemplateGame = v;
    }

    /**
      Get Entry Template
    */
    static
    QString templateGame()
    {
      return self()->mTemplateGame;
    }

    /**
      Is Entry Template Immutable
    */
    static
    bool isTemplateGameImmutable()
    {
      return self()->isImmutable( QStringLiteral( "templateGame" ) );
    }

    /**
      Set Template font
    */
    static
    void setFontGame( const QFont & v )
    {
      if (!self()->isFontGameImmutable())
        self()->mFontGame = v;
    }

    /**
      Get Template font
    */
    static
    QFont fontGame()
    {
      return self()->mFontGame;
    }

    /**
      Is Template font Immutable
    */
    static
    bool isFontGameImmutable()
    {
      return self()->isImmutable( QStringLiteral( "fontGame" ) );
    }

    /**
      Set Template background color
    */
    static
    void setBaseColorGame( const QColor & v )
    {
      if (!self()->isBaseColorGameImmutable())
        self()->mBaseColorGame = v;
    }

    /**
      Get Template background color
    */
    static
    QColor baseColorGame()
    {
      return self()->mBaseColorGame;
    }

    /**
      Is Template background color Immutable
    */
    static
    bool isBaseColorGameImmutable()
    {
      return self()->isImmutable( QStringLiteral( "baseColorGame" ) );
    }

    /**
      Set Template text color
    */
    static
    void setTextColorGame( const QColor & v )
    {
      if (!self()->isTextColorGameImmutable())
        self()->mTextColorGame = v;
    }

    /**
      Get Template text color
    */
    static
    QColor textColorGame()
    {
      return self()->mTextColorGame;
    }

    /**
      Is Template text color Immutable
    */
    static
    bool isTextColorGameImmutable()
    {
      return self()->isImmutable( QStringLiteral( "textColorGame" ) );
    }

    /**
      Set Template highlight color
    */
    static
    void setHighlightedBaseColorGame( const QColor & v )
    {
      if (!self()->isHighlightedBaseColorGameImmutable())
        self()->mHighlightedBaseColorGame = v;
    }

    /**
      Get Template highlight color
    */
    static
    QColor highlightedBaseColorGame()
    {
      return self()->mHighlightedBaseColorGame;
    }

    /**
      Is Template highlight color Immutable
    */
    static
    bool isHighlightedBaseColorGameImmutable()
    {
      return self()->isImmutable( QStringLiteral( "highlightedBaseColorGame" ) );
    }

    /**
      Set Template highlighted text color
    */
    static
    void setHighlightedTextColorGame( const QColor & v )
    {
      if (!self()->isHighlightedTextColorGameImmutable())
        self()->mHighlightedTextColorGame = v;
    }

    /**
      Get Template highlighted text color
    */
    static
    QColor highlightedTextColorGame()
    {
      return self()->mHighlightedTextColorGame;
    }

    /**
      Is Template highlighted text color Immutable
    */
    static
    bool isHighlightedTextColorGameImmutable()
    {
      return self()->isImmutable( QStringLiteral( "highlightedTextColorGame" ) );
    }

    /**
      Set Template link color
    */
    static
    void setLinkColorGame( const QColor & v )
    {
      if (!self()->isLinkColorGameImmutable())
        self()->mLinkColorGame = v;
    }

    /**
      Get Template link color
    */
    static
    QColor linkColorGame()
    {
      return self()->mLinkColorGame;
    }

    /**
      Is Template link color Immutable
    */
    static
    bool isLinkColorGameImmutable()
    {
      return self()->isImmutable( QStringLiteral( "linkColorGame" ) );
    }

    /**
      Set Entry Template
    */
    static
    void setTemplateFile( const QString & v )
    {
      if (!self()->isTemplateFileImmutable())
        self()->mTemplateFile = v;
    }

    /**
      Get Entry Template
    */
    static
    QString templateFile()
    {
      return self()->mTemplateFile;
    }

    /**
      Is Entry Template Immutable
    */
    static
    bool isTemplateFileImmutable()
    {
      return self()->isImmutable( QStringLiteral( "templateFile" ) );
    }

    /**
      Set Template font
    */
    static
    void setFontFile( const QFont & v )
    {
      if (!self()->isFontFileImmutable())
        self()->mFontFile = v;
    }

    /**
      Get Template font
    */
    static
    QFont fontFile()
    {
      return self()->mFontFile;
    }

    /**
      Is Template font Immutable
    */
    static
    bool isFontFileImmutable()
    {
      return self()->isImmutable( QStringLiteral( "fontFile" ) );
    }

    /**
      Set Template background color
    */
    static
    void setBaseColorFile( const QColor & v )
    {
      if (!self()->isBaseColorFileImmutable())
        self()->mBaseColorFile = v;
    }

    /**
      Get Template background color
    */
    static
    QColor baseColorFile()
    {
      return self()->mBaseColorFile;
    }

    /**
      Is Template background color Immutable
    */
    static
    bool isBaseColorFileImmutable()
    {
      return self()->isImmutable( QStringLiteral( "baseColorFile" ) );
    }

    /**
      Set Template text color
    */
    static
    void setTextColorFile( const QColor & v )
    {
      if (!self()->isTextColorFileImmutable())
        self()->mTextColorFile = v;
    }

    /**
      Get Template text color
    */
    static
    QColor textColorFile()
    {
      return self()->mTextColorFile;
    }

    /**
      Is Template text color Immutable
    */
    static
    bool isTextColorFileImmutable()
    {
      return self()->isImmutable( QStringLiteral( "textColorFile" ) );
    }

    /**
      Set Template highlight color
    */
    static
    void setHighlightedBaseColorFile( const QColor & v )
    {
      if (!self()->isHighlightedBaseColorFileImmutable())
        self()->mHighlightedBaseColorFile = v;
    }

    /**
      Get Template highlight color
    */
    static
    QColor highlightedBaseColorFile()
    {
      return self()->mHighlightedBaseColorFile;
    }

    /**
      Is Template highlight color Immutable
    */
    static
    bool isHighlightedBaseColorFileImmutable()
    {
      return self()->isImmutable( QStringLiteral( "highlightedBaseColorFile" ) );
    }

    /**
      Set Template highlighted text color
    */
    static
    void setHighlightedTextColorFile( const QColor & v )
    {
      if (!self()->isHighlightedTextColorFileImmutable())
        self()->mHighlightedTextColorFile = v;
    }

    /**
      Get Template highlighted text color
    */
    static
    QColor highlightedTextColorFile()
    {
      return self()->mHighlightedTextColorFile;
    }

    /**
      Is Template highlighted text color Immutable
    */
    static
    bool isHighlightedTextColorFileImmutable()
    {
      return self()->isImmutable( QStringLiteral( "highlightedTextColorFile" ) );
    }

    /**
      Set Template link color
    */
    static
    void setLinkColorFile( const QColor & v )
    {
      if (!self()->isLinkColorFileImmutable())
        self()->mLinkColorFile = v;
    }

    /**
      Get Template link color
    */
    static
    QColor linkColorFile()
    {
      return self()->mLinkColorFile;
    }

    /**
      Is Template link color Immutable
    */
    static
    bool isLinkColorFileImmutable()
    {
      return self()->isImmutable( QStringLiteral( "linkColorFile" ) );
    }

    /**
      Set Entry Template
    */
    static
    void setTemplateBoardGame( const QString & v )
    {
      if (!self()->isTemplateBoardGameImmutable())
        self()->mTemplateBoardGame = v;
    }

    /**
      Get Entry Template
    */
    static
    QString templateBoardGame()
    {
      return self()->mTemplateBoardGame;
    }

    /**
      Is Entry Template Immutable
    */
    static
    bool isTemplateBoardGameImmutable()
    {
      return self()->isImmutable( QStringLiteral( "templateBoardGame" ) );
    }

    /**
      Set Template font
    */
    static
    void setFontBoardGame( const QFont & v )
    {
      if (!self()->isFontBoardGameImmutable())
        self()->mFontBoardGame = v;
    }

    /**
      Get Template font
    */
    static
    QFont fontBoardGame()
    {
      return self()->mFontBoardGame;
    }

    /**
      Is Template font Immutable
    */
    static
    bool isFontBoardGameImmutable()
    {
      return self()->isImmutable( QStringLiteral( "fontBoardGame" ) );
    }

    /**
      Set Template background color
    */
    static
    void setBaseColorBoardGame( const QColor & v )
    {
      if (!self()->isBaseColorBoardGameImmutable())
        self()->mBaseColorBoardGame = v;
    }

    /**
      Get Template background color
    */
    static
    QColor baseColorBoardGame()
    {
      return self()->mBaseColorBoardGame;
    }

    /**
      Is Template background color Immutable
    */
    static
    bool isBaseColorBoardGameImmutable()
    {
      return self()->isImmutable( QStringLiteral( "baseColorBoardGame" ) );
    }

    /**
      Set Template text color
    */
    static
    void setTextColorBoardGame( const QColor & v )
    {
      if (!self()->isTextColorBoardGameImmutable())
        self()->mTextColorBoardGame = v;
    }

    /**
      Get Template text color
    */
    static
    QColor textColorBoardGame()
    {
      return self()->mTextColorBoardGame;
    }

    /**
      Is Template text color Immutable
    */
    static
    bool isTextColorBoardGameImmutable()
    {
      return self()->isImmutable( QStringLiteral( "textColorBoardGame" ) );
    }

    /**
      Set Template highlight color
    */
    static
    void setHighlightedBaseColorBoardGame( const QColor & v )
    {
      if (!self()->isHighlightedBaseColorBoardGameImmutable())
        self()->mHighlightedBaseColorBoardGame = v;
    }

    /**
      Get Template highlight color
    */
    static
    QColor highlightedBaseColorBoardGame()
    {
      return self()->mHighlightedBaseColorBoardGame;
    }

    /**
      Is Template highlight color Immutable
    */
    static
    bool isHighlightedBaseColorBoardGameImmutable()
    {
      return self()->isImmutable( QStringLiteral( "highlightedBaseColorBoardGame" ) );
    }

    /**
      Set Template highlighted text color
    */
    static
    void setHighlightedTextColorBoardGame( const QColor & v )
    {
      if (!self()->isHighlightedTextColorBoardGameImmutable())
        self()->mHighlightedTextColorBoardGame = v;
    }

    /**
      Get Template highlighted text color
    */
    static
    QColor highlightedTextColorBoardGame()
    {
      return self()->mHighlightedTextColorBoardGame;
    }

    /**
      Is Template highlighted text color Immutable
    */
    static
    bool isHighlightedTextColorBoardGameImmutable()
    {
      return self()->isImmutable( QStringLiteral( "highlightedTextColorBoardGame" ) );
    }

    /**
      Set Template link color
    */
    static
    void setLinkColorBoardGame( const QColor & v )
    {
      if (!self()->isLinkColorBoardGameImmutable())
        self()->mLinkColorBoardGame = v;
    }

    /**
      Get Template link color
    */
    static
    QColor linkColorBoardGame()
    {
      return self()->mLinkColorBoardGame;
    }

    /**
      Is Template link color Immutable
    */
    static
    bool isLinkColorBoardGameImmutable()
    {
      return self()->isImmutable( QStringLiteral( "linkColorBoardGame" ) );
    }

    /**
      Set Entry Template
    */
    static
    void setTemplateBase( const QString & v )
    {
      if (!self()->isTemplateBaseImmutable())
        self()->mTemplateBase = v;
    }

    /**
      Get Entry Template
    */
    static
    QString templateBase()
    {
      return self()->mTemplateBase;
    }

    /**
      Is Entry Template Immutable
    */
    static
    bool isTemplateBaseImmutable()
    {
      return self()->isImmutable( QStringLiteral( "templateBase" ) );
    }

    /**
      Set Template font
    */
    static
    void setFontBase( const QFont & v )
    {
      if (!self()->isFontBaseImmutable())
        self()->mFontBase = v;
    }

    /**
      Get Template font
    */
    static
    QFont fontBase()
    {
      return self()->mFontBase;
    }

    /**
      Is Template font Immutable
    */
    static
    bool isFontBaseImmutable()
    {
      return self()->isImmutable( QStringLiteral( "fontBase" ) );
    }

    /**
      Set Template background color
    */
    static
    void setBaseColorBase( const QColor & v )
    {
      if (!self()->isBaseColorBaseImmutable())
        self()->mBaseColorBase = v;
    }

    /**
      Get Template background color
    */
    static
    QColor baseColorBase()
    {
      return self()->mBaseColorBase;
    }

    /**
      Is Template background color Immutable
    */
    static
    bool isBaseColorBaseImmutable()
    {
      return self()->isImmutable( QStringLiteral( "baseColorBase" ) );
    }

    /**
      Set Template text color
    */
    static
    void setTextColorBase( const QColor & v )
    {
      if (!self()->isTextColorBaseImmutable())
        self()->mTextColorBase = v;
    }

    /**
      Get Template text color
    */
    static
    QColor textColorBase()
    {
      return self()->mTextColorBase;
    }

    /**
      Is Template text color Immutable
    */
    static
    bool isTextColorBaseImmutable()
    {
      return self()->isImmutable( QStringLiteral( "textColorBase" ) );
    }

    /**
      Set Template highlight color
    */
    static
    void setHighlightedBaseColorBase( const QColor & v )
    {
      if (!self()->isHighlightedBaseColorBaseImmutable())
        self()->mHighlightedBaseColorBase = v;
    }

    /**
      Get Template highlight color
    */
    static
    QColor highlightedBaseColorBase()
    {
      return self()->mHighlightedBaseColorBase;
    }

    /**
      Is Template highlight color Immutable
    */
    static
    bool isHighlightedBaseColorBaseImmutable()
    {
      return self()->isImmutable( QStringLiteral( "highlightedBaseColorBase" ) );
    }

    /**
      Set Template highlighted text color
    */
    static
    void setHighlightedTextColorBase( const QColor & v )
    {
      if (!self()->isHighlightedTextColorBaseImmutable())
        self()->mHighlightedTextColorBase = v;
    }

    /**
      Get Template highlighted text color
    */
    static
    QColor highlightedTextColorBase()
    {
      return self()->mHighlightedTextColorBase;
    }

    /**
      Is Template highlighted text color Immutable
    */
    static
    bool isHighlightedTextColorBaseImmutable()
    {
      return self()->isImmutable( QStringLiteral( "highlightedTextColorBase" ) );
    }

    /**
      Set Template link color
    */
    static
    void setLinkColorBase( const QColor & v )
    {
      if (!self()->isLinkColorBaseImmutable())
        self()->mLinkColorBase = v;
    }

    /**
      Get Template link color
    */
    static
    QColor linkColorBase()
    {
      return self()->mLinkColorBase;
    }

    /**
      Is Template link color Immutable
    */
    static
    bool isLinkColorBaseImmutable()
    {
      return self()->isImmutable( QStringLiteral( "linkColorBase" ) );
    }

  protected:
    Config();
    friend class ConfigHelper;


    // Group View Options
    int mGroupViewSortColumn;
    bool mGroupViewSortAscending;

    // Filter View Options
    int mFilterViewSortColumn;
    bool mFilterViewSortAscending;

    // Loan View Options
    int mLoanViewSortColumn;
    bool mLoanViewSortAscending;

    // Export Options - Bibtex
    bool mUseBraces;

    // General Options
    bool mShowEditWidget;
    int mViewWidget;
    bool mLockLayout;
    int mImageLocation;
    bool mAskWriteImagesInFile;
    bool mReopenLastFile;
    bool mAutoCapitalization;
    bool mAutoFormat;
    QString mLastOpenFile;
    QString mNoCapitalizationString;
    QString mArticlesString;
    QString mNameSuffixesString;
    QString mSurnamePrefixesString;
    int mMaxIconSize;
    int mIconCacheSize;
    quint64 mImageCacheSize;
    int mMaxCustomURLSettings;
    bool mEnableWebcam;
    bool mQuickFilterRegExp;
    bool mShowWelcome;

    // Printing
    bool mPrintFieldHeaders;
    bool mPrintFormatted;
    bool mPrintGrouped;
    int mMaxImageWidth;
    int mMaxImageHeight;

    // Options - book
    QString mTemplateBook;
    QFont mFontBook;
    QColor mBaseColorBook;
    QColor mTextColorBook;
    QColor mHighlightedBaseColorBook;
    QColor mHighlightedTextColorBook;
    QColor mLinkColorBook;

    // Options - video
    QString mTemplateVideo;
    QFont mFontVideo;
    QColor mBaseColorVideo;
    QColor mTextColorVideo;
    QColor mHighlightedBaseColorVideo;
    QColor mHighlightedTextColorVideo;
    QColor mLinkColorVideo;

    // Options - album
    QString mTemplateAlbum;
    QFont mFontAlbum;
    QColor mBaseColorAlbum;
    QColor mTextColorAlbum;
    QColor mHighlightedBaseColorAlbum;
    QColor mHighlightedTextColorAlbum;
    QColor mLinkColorAlbum;

    // Options - bibtex
    QString mLyxpipe;
    QString mTemplateBibtex;
    QFont mFontBibtex;
    QColor mBaseColorBibtex;
    QColor mTextColorBibtex;
    QColor mHighlightedBaseColorBibtex;
    QColor mHighlightedTextColorBibtex;
    QColor mLinkColorBibtex;

    // Options - comic
    QString mTemplateComicBook;
    QFont mFontComicBook;
    QColor mBaseColorComicBook;
    QColor mTextColorComicBook;
    QColor mHighlightedBaseColorComicBook;
    QColor mHighlightedTextColorComicBook;
    QColor mLinkColorComicBook;

    // Options - wine
    QString mTemplateWine;
    QFont mFontWine;
    QColor mBaseColorWine;
    QColor mTextColorWine;
    QColor mHighlightedBaseColorWine;
    QColor mHighlightedTextColorWine;
    QColor mLinkColorWine;

    // Options - coin
    QString mTemplateCoin;
    QFont mFontCoin;
    QColor mBaseColorCoin;
    QColor mTextColorCoin;
    QColor mHighlightedBaseColorCoin;
    QColor mHighlightedTextColorCoin;
    QColor mLinkColorCoin;

    // Options - stamp
    QString mTemplateStamp;
    QFont mFontStamp;
    QColor mBaseColorStamp;
    QColor mTextColorStamp;
    QColor mHighlightedBaseColorStamp;
    QColor mHighlightedTextColorStamp;
    QColor mLinkColorStamp;

    // Options - card
    QString mTemplateCard;
    QFont mFontCard;
    QColor mBaseColorCard;
    QColor mTextColorCard;
    QColor mHighlightedBaseColorCard;
    QColor mHighlightedTextColorCard;
    QColor mLinkColorCard;

    // Options - game
    QString mTemplateGame;
    QFont mFontGame;
    QColor mBaseColorGame;
    QColor mTextColorGame;
    QColor mHighlightedBaseColorGame;
    QColor mHighlightedTextColorGame;
    QColor mLinkColorGame;

    // Options - file
    QString mTemplateFile;
    QFont mFontFile;
    QColor mBaseColorFile;
    QColor mTextColorFile;
    QColor mHighlightedBaseColorFile;
    QColor mHighlightedTextColorFile;
    QColor mLinkColorFile;

    // Options - boardgame
    QString mTemplateBoardGame;
    QFont mFontBoardGame;
    QColor mBaseColorBoardGame;
    QColor mTextColorBoardGame;
    QColor mHighlightedBaseColorBoardGame;
    QColor mHighlightedTextColorBoardGame;
    QColor mLinkColorBoardGame;

    // Options - entry
    QString mTemplateBase;
    QFont mFontBase;
    QColor mBaseColorBase;
    QColor mTextColorBase;
    QColor mHighlightedBaseColorBase;
    QColor mHighlightedTextColorBase;
    QColor mLinkColorBase;
    // Include custom additions
    #include "tellico_config_addons.h"
};

}

#endif

