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

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

#include <basictypes.h>
#include <codegenerationpolicy.h>
#include <codegenerators/cpp/cppcodegenerationpolicy.h>

class UmbrelloSettings : public KConfigSkeleton
{
  public:

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

    /**
      Set Geometry
    */
    static
    void setGeometry( const QSize & v )
    {
      if (!self()->isGeometryImmutable())
        self()->mGeometry = v;
    }

    /**
      Get Geometry
    */
    static
    QSize geometry()
    {
      return self()->mGeometry;
    }

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

    /**
      Set Image Mime Type
    */
    static
    void setImageMimeType( const QString & v )
    {
      if (!self()->isImageMimeTypeImmutable())
        self()->mImageMimeType = v;
    }

    /**
      Get Image Mime Type
    */
    static
    QString imageMimeType()
    {
      return self()->mImageMimeType;
    }

    /**
      Is Image Mime Type Immutable
    */
    static
    bool isImageMimeTypeImmutable()
    {
      return self()->isImmutable( QStringLiteral( "imageMimeType" ) );
    }

    /**
      Set Undo Support
    */
    static
    void setUndo( bool v )
    {
      if (!self()->isUndoImmutable())
        self()->mUndo = v;
    }

    /**
      Get Undo Support
    */
    static
    bool undo()
    {
      return self()->mUndo;
    }

    /**
      Is Undo Support Immutable
    */
    static
    bool isUndoImmutable()
    {
      return self()->isImmutable( QStringLiteral( "undo" ) );
    }

    /**
      Set Tabbed Diagrams
    */
    static
    void setTabdiagrams( bool v )
    {
      if (!self()->isTabdiagramsImmutable())
        self()->mTabdiagrams = v;
    }

    /**
      Get Tabbed Diagrams
    */
    static
    bool tabdiagrams()
    {
      return self()->mTabdiagrams;
    }

    /**
      Is Tabbed Diagrams Immutable
    */
    static
    bool isTabdiagramsImmutable()
    {
      return self()->isImmutable( QStringLiteral( "tabdiagrams" ) );
    }

    /**
      Set New Code Generator
    */
    static
    void setNewcodegen( bool v )
    {
      if (!self()->isNewcodegenImmutable())
        self()->mNewcodegen = v;
    }

    /**
      Get New Code Generator
    */
    static
    bool newcodegen()
    {
      return self()->mNewcodegen;
    }

    /**
      Is New Code Generator Immutable
    */
    static
    bool isNewcodegenImmutable()
    {
      return self()->isImmutable( QStringLiteral( "newcodegen" ) );
    }

    /**
      Set Layout Type
    */
    static
    void setLayoutType( Uml::LayoutType::Enum v )
    {
      if (!self()->isLayoutTypeImmutable())
        self()->mLayoutType = v;
    }

    /**
      Get Layout Type
    */
    static
    Uml::LayoutType::Enum layoutType()
    {
      return static_cast<Uml::LayoutType::Enum>(self()->mLayoutType);
    }

    /**
      Is Layout Type Immutable
    */
    static
    bool isLayoutTypeImmutable()
    {
      return self()->isImmutable( QStringLiteral( "layoutType" ) );
    }

    /**
      Set Footer Printing
    */
    static
    void setFooterPrinting( bool v )
    {
      if (!self()->isFooterPrintingImmutable())
        self()->mFooterPrinting = v;
    }

    /**
      Get Footer Printing
    */
    static
    bool footerPrinting()
    {
      return self()->mFooterPrinting;
    }

    /**
      Is Footer Printing Immutable
    */
    static
    bool isFooterPrintingImmutable()
    {
      return self()->isImmutable( QStringLiteral( "footerPrinting" ) );
    }

    /**
      Set Auto Save
    */
    static
    void setAutosave( bool v )
    {
      if (!self()->isAutosaveImmutable())
        self()->mAutosave = v;
    }

    /**
      Get Auto Save
    */
    static
    bool autosave()
    {
      return self()->mAutosave;
    }

    /**
      Is Auto Save Immutable
    */
    static
    bool isAutosaveImmutable()
    {
      return self()->isImmutable( QStringLiteral( "autosave" ) );
    }

    /**
      Set Auto Save Time ( Old )
    */
    static
    void setTime( int v )
    {
      if (v < 0)
      {
        qDebug() << "setTime: value " << v << " is less than the minimum value of 0";
        v = 0;
      }

      if (v > 25)
      {
        qDebug() << "setTime: value " << v << " is greater than the maximum value of 25";
        v = 25;
      }

      if (!self()->isTimeImmutable())
        self()->mTime = v;
    }

    /**
      Get Auto Save Time ( Old )
    */
    static
    int time()
    {
      return self()->mTime;
    }

    /**
      Is Auto Save Time ( Old ) Immutable
    */
    static
    bool isTimeImmutable()
    {
      return self()->isImmutable( QStringLiteral( "time" ) );
    }

    /**
      Set autosavetime
    */
    static
    void setAutosavetime( int v )
    {
      if (v < 0)
      {
        qDebug() << "setAutosavetime: value " << v << " is less than the minimum value of 0";
        v = 0;
      }

      if (v > 25)
      {
        qDebug() << "setAutosavetime: value " << v << " is greater than the maximum value of 25";
        v = 25;
      }

      if (!self()->isAutosavetimeImmutable())
        self()->mAutosavetime = v;
    }

    /**
      Get autosavetime
    */
    static
    int autosavetime()
    {
      return self()->mAutosavetime;
    }

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

    /**
      Set Auto Save Suffix
    */
    static
    void setAutosavesuffix( const QString & v )
    {
      if (!self()->isAutosavesuffixImmutable())
        self()->mAutosavesuffix = v;
    }

    /**
      Get Auto Save Suffix
    */
    static
    QString autosavesuffix()
    {
      return self()->mAutosavesuffix;
    }

    /**
      Is Auto Save Suffix Immutable
    */
    static
    bool isAutosavesuffixImmutable()
    {
      return self()->isImmutable( QStringLiteral( "autosavesuffix" ) );
    }

    /**
      Set Load Last
    */
    static
    void setLoadlast( bool v )
    {
      if (!self()->isLoadlastImmutable())
        self()->mLoadlast = v;
    }

    /**
      Get Load Last
    */
    static
    bool loadlast()
    {
      return self()->mLoadlast;
    }

    /**
      Is Load Last Immutable
    */
    static
    bool isLoadlastImmutable()
    {
      return self()->isImmutable( QStringLiteral( "loadlast" ) );
    }

    /**
      Set Diagram To Load at Startup
    */
    static
    void setDiagram( Uml::DiagramType::Enum v )
    {
      if (!self()->isDiagramImmutable())
        self()->mDiagram = v;
    }

    /**
      Get Diagram To Load at Startup
    */
    static
    Uml::DiagramType::Enum diagram()
    {
      return static_cast<Uml::DiagramType::Enum>(self()->mDiagram);
    }

    /**
      Is Diagram To Load at Startup Immutable
    */
    static
    bool isDiagramImmutable()
    {
      return self()->isImmutable( QStringLiteral( "diagram" ) );
    }

    /**
      Set Default Language at Startup
    */
    static
    void setDefaultLanguage( Uml::ProgrammingLanguage::Enum v )
    {
      if (!self()->isDefaultLanguageImmutable())
        self()->mDefaultLanguage = v;
    }

    /**
      Get Default Language at Startup
    */
    static
    Uml::ProgrammingLanguage::Enum defaultLanguage()
    {
      return static_cast<Uml::ProgrammingLanguage::Enum>(self()->mDefaultLanguage);
    }

    /**
      Is Default Language at Startup Immutable
    */
    static
    bool isDefaultLanguageImmutable()
    {
      return self()->isImmutable( QStringLiteral( "defaultLanguage" ) );
    }

    /**
      Set lastFile
    */
    static
    void setLastFile( const QString & v )
    {
      if (!self()->isLastFileImmutable())
        self()->mLastFile = v;
    }

    /**
      Get lastFile
    */
    static
    QString lastFile()
    {
      return self()->mLastFile;
    }

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

    /**
      Set Use UML-2.x Notation
    */
    static
    void setUml2( bool v )
    {
      if (!self()->isUml2Immutable())
        self()->mUml2 = v;
    }

    /**
      Get Use UML-2.x Notation
    */
    static
    bool uml2()
    {
      return self()->mUml2;
    }

    /**
      Is Use UML-2.x Notation Immutable
    */
    static
    bool isUml2Immutable()
    {
      return self()->isImmutable( QStringLiteral( "uml2" ) );
    }

    /**
      Set Show debug windows
    */
    static
    void setShowDebugWindows( bool v )
    {
      if (!self()->isShowDebugWindowsImmutable())
        self()->mShowDebugWindows = v;
    }

    /**
      Get Show debug windows
    */
    static
    bool showDebugWindows()
    {
      return self()->mShowDebugWindows;
    }

    /**
      Is Show debug windows Immutable
    */
    static
    bool isShowDebugWindowsImmutable()
    {
      return self()->isImmutable( QStringLiteral( "showDebugWindows" ) );
    }

    /**
      Set Use Fill Color
    */
    static
    void setUseFillColor( bool v )
    {
      if (!self()->isUseFillColorImmutable())
        self()->mUseFillColor = v;
    }

    /**
      Get Use Fill Color
    */
    static
    bool useFillColor()
    {
      return self()->mUseFillColor;
    }

    /**
      Is Use Fill Color Immutable
    */
    static
    bool isUseFillColorImmutable()
    {
      return self()->isImmutable( QStringLiteral( "useFillColor" ) );
    }

    /**
      Set Fill Color
    */
    static
    void setFillColor( const QColor & v )
    {
      if (!self()->isFillColorImmutable())
        self()->mFillColor = v;
    }

    /**
      Get Fill Color
    */
    static
    QColor fillColor()
    {
      return self()->mFillColor;
    }

    /**
      Is Fill Color Immutable
    */
    static
    bool isFillColorImmutable()
    {
      return self()->isImmutable( QStringLiteral( "fillColor" ) );
    }

    /**
      Set Line Color
    */
    static
    void setLineColor( const QColor & v )
    {
      if (!self()->isLineColorImmutable())
        self()->mLineColor = v;
    }

    /**
      Get Line Color
    */
    static
    QColor lineColor()
    {
      return self()->mLineColor;
    }

    /**
      Is Line Color Immutable
    */
    static
    bool isLineColorImmutable()
    {
      return self()->isImmutable( QStringLiteral( "lineColor" ) );
    }

    /**
      Set Line Width
    */
    static
    void setLineWidth( uint v )
    {
      if (!self()->isLineWidthImmutable())
        self()->mLineWidth = v;
    }

    /**
      Get Line Width
    */
    static
    uint lineWidth()
    {
      return self()->mLineWidth;
    }

    /**
      Is Line Width Immutable
    */
    static
    bool isLineWidthImmutable()
    {
      return self()->isImmutable( QStringLiteral( "lineWidth" ) );
    }

    /**
      Set Text Color
    */
    static
    void setTextColor( const QColor & v )
    {
      if (!self()->isTextColorImmutable())
        self()->mTextColor = v;
    }

    /**
      Get Text Color
    */
    static
    QColor textColor()
    {
      return self()->mTextColor;
    }

    /**
      Is Text Color Immutable
    */
    static
    bool isTextColorImmutable()
    {
      return self()->isImmutable( QStringLiteral( "textColor" ) );
    }

    /**
      Set Show Doc Window
    */
    static
    void setShowDocWindow( bool v )
    {
      if (!self()->isShowDocWindowImmutable())
        self()->mShowDocWindow = v;
    }

    /**
      Get Show Doc Window
    */
    static
    bool showDocWindow()
    {
      return self()->mShowDocWindow;
    }

    /**
      Is Show Doc Window Immutable
    */
    static
    bool isShowDocWindowImmutable()
    {
      return self()->isImmutable( QStringLiteral( "showDocWindow" ) );
    }

    /**
      Set Font
    */
    static
    void setUiFont( const QFont & v )
    {
      if (!self()->isUiFontImmutable())
        self()->mUiFont = v;
    }

    /**
      Get Font
    */
    static
    QFont uiFont()
    {
      return self()->mUiFont;
    }

    /**
      Is Font Immutable
    */
    static
    bool isUiFontImmutable()
    {
      return self()->isImmutable( QStringLiteral( "uiFont" ) );
    }

    /**
      Set Background Color
    */
    static
    void setBackgroundColor( const QColor & v )
    {
      if (!self()->isBackgroundColorImmutable())
        self()->mBackgroundColor = v;
    }

    /**
      Get Background Color
    */
    static
    QColor backgroundColor()
    {
      return self()->mBackgroundColor;
    }

    /**
      Is Background Color Immutable
    */
    static
    bool isBackgroundColorImmutable()
    {
      return self()->isImmutable( QStringLiteral( "backgroundColor" ) );
    }

    /**
      Set Use background color
    */
    static
    void setUseBackgroundColor( bool v )
    {
      if (!self()->isUseBackgroundColorImmutable())
        self()->mUseBackgroundColor = v;
    }

    /**
      Get Use background color
    */
    static
    bool useBackgroundColor()
    {
      return self()->mUseBackgroundColor;
    }

    /**
      Is Use background color Immutable
    */
    static
    bool isUseBackgroundColorImmutable()
    {
      return self()->isImmutable( QStringLiteral( "useBackgroundColor" ) );
    }

    /**
      Set Grid Dot Color
    */
    static
    void setGridDotColor( const QColor & v )
    {
      if (!self()->isGridDotColorImmutable())
        self()->mGridDotColor = v;
    }

    /**
      Get Grid Dot Color
    */
    static
    QColor gridDotColor()
    {
      return self()->mGridDotColor;
    }

    /**
      Is Grid Dot Color Immutable
    */
    static
    bool isGridDotColorImmutable()
    {
      return self()->isImmutable( QStringLiteral( "gridDotColor" ) );
    }

    /**
      Set Use Alignment Guides
    */
    static
    void setUseAlignmentGuides( bool v )
    {
      if (!self()->isUseAlignmentGuidesImmutable())
        self()->mUseAlignmentGuides = v;
    }

    /**
      Get Use Alignment Guides
    */
    static
    bool useAlignmentGuides()
    {
      return self()->mUseAlignmentGuides;
    }

    /**
      Is Use Alignment Guides Immutable
    */
    static
    bool isUseAlignmentGuidesImmutable()
    {
      return self()->isImmutable( QStringLiteral( "useAlignmentGuides" ) );
    }

    /**
      Set Right to left user interface
    */
    static
    void setRightToLeftUI( bool v )
    {
      if (!self()->isRightToLeftUIImmutable())
        self()->mRightToLeftUI = v;
    }

    /**
      Get Right to left user interface
    */
    static
    bool rightToLeftUI()
    {
      return self()->mRightToLeftUI;
    }

    /**
      Is Right to left user interface Immutable
    */
    static
    bool isRightToLeftUIImmutable()
    {
      return self()->isImmutable( QStringLiteral( "rightToLeftUI" ) );
    }

    /**
      Set Show Visibility
    */
    static
    void setShowVisibility( bool v )
    {
      if (!self()->isShowVisibilityImmutable())
        self()->mShowVisibility = v;
    }

    /**
      Get Show Visibility
    */
    static
    bool showVisibility()
    {
      return self()->mShowVisibility;
    }

    /**
      Is Show Visibility Immutable
    */
    static
    bool isShowVisibilityImmutable()
    {
      return self()->isImmutable( QStringLiteral( "showVisibility" ) );
    }

    /**
      Set Show Attributes
    */
    static
    void setShowAtts( bool v )
    {
      if (!self()->isShowAttsImmutable())
        self()->mShowAtts = v;
    }

    /**
      Get Show Attributes
    */
    static
    bool showAtts()
    {
      return self()->mShowAtts;
    }

    /**
      Is Show Attributes Immutable
    */
    static
    bool isShowAttsImmutable()
    {
      return self()->isImmutable( QStringLiteral( "showAtts" ) );
    }

    /**
      Set Show Operations
    */
    static
    void setShowOps( bool v )
    {
      if (!self()->isShowOpsImmutable())
        self()->mShowOps = v;
    }

    /**
      Get Show Operations
    */
    static
    bool showOps()
    {
      return self()->mShowOps;
    }

    /**
      Is Show Operations Immutable
    */
    static
    bool isShowOpsImmutable()
    {
      return self()->isImmutable( QStringLiteral( "showOps" ) );
    }

    /**
      Set Show Package
    */
    static
    void setShowPackage( bool v )
    {
      if (!self()->isShowPackageImmutable())
        self()->mShowPackage = v;
    }

    /**
      Get Show Package
    */
    static
    bool showPackage()
    {
      return self()->mShowPackage;
    }

    /**
      Is Show Package Immutable
    */
    static
    bool isShowPackageImmutable()
    {
      return self()->isImmutable( QStringLiteral( "showPackage" ) );
    }

    /**
      Set Show Stereotypes
    */
    static
    void setShowStereoType( Uml::ShowStereoType::Enum v )
    {
      if (!self()->isShowStereoTypeImmutable())
        self()->mShowStereoType = v;
    }

    /**
      Get Show Stereotypes
    */
    static
    Uml::ShowStereoType::Enum showStereoType()
    {
      return static_cast<Uml::ShowStereoType::Enum>(self()->mShowStereoType);
    }

    /**
      Is Show Stereotypes Immutable
    */
    static
    bool isShowStereoTypeImmutable()
    {
      return self()->isImmutable( QStringLiteral( "showStereoType" ) );
    }

    /**
      Set Show Attribute Associations
    */
    static
    void setShowAttribAssocs( bool v )
    {
      if (!self()->isShowAttribAssocsImmutable())
        self()->mShowAttribAssocs = v;
    }

    /**
      Get Show Attribute Associations
    */
    static
    bool showAttribAssocs()
    {
      return self()->mShowAttribAssocs;
    }

    /**
      Is Show Attribute Associations Immutable
    */
    static
    bool isShowAttribAssocsImmutable()
    {
      return self()->isImmutable( QStringLiteral( "showAttribAssocs" ) );
    }

    /**
      Set Show Public Only
    */
    static
    void setShowPublicOnly( bool v )
    {
      if (!self()->isShowPublicOnlyImmutable())
        self()->mShowPublicOnly = v;
    }

    /**
      Get Show Public Only
    */
    static
    bool showPublicOnly()
    {
      return self()->mShowPublicOnly;
    }

    /**
      Is Show Public Only Immutable
    */
    static
    bool isShowPublicOnlyImmutable()
    {
      return self()->isImmutable( QStringLiteral( "showPublicOnly" ) );
    }

    /**
      Set Show Attribute Signature
    */
    static
    void setShowAttSig( bool v )
    {
      if (!self()->isShowAttSigImmutable())
        self()->mShowAttSig = v;
    }

    /**
      Get Show Attribute Signature
    */
    static
    bool showAttSig()
    {
      return self()->mShowAttSig;
    }

    /**
      Is Show Attribute Signature Immutable
    */
    static
    bool isShowAttSigImmutable()
    {
      return self()->isImmutable( QStringLiteral( "showAttSig" ) );
    }

    /**
      Set Show Operation Signature
    */
    static
    void setShowOpSig( bool v )
    {
      if (!self()->isShowOpSigImmutable())
        self()->mShowOpSig = v;
    }

    /**
      Get Show Operation Signature
    */
    static
    bool showOpSig()
    {
      return self()->mShowOpSig;
    }

    /**
      Is Show Operation Signature Immutable
    */
    static
    bool isShowOpSigImmutable()
    {
      return self()->isImmutable( QStringLiteral( "showOpSig" ) );
    }

    /**
      Set Default Attribute Scope
    */
    static
    void setDefaultAttributeScope( Uml::Visibility::Enum v )
    {
      if (!self()->isDefaultAttributeScopeImmutable())
        self()->mDefaultAttributeScope = v;
    }

    /**
      Get Default Attribute Scope
    */
    static
    Uml::Visibility::Enum defaultAttributeScope()
    {
      return static_cast<Uml::Visibility::Enum>(self()->mDefaultAttributeScope);
    }

    /**
      Is Default Attribute Scope Immutable
    */
    static
    bool isDefaultAttributeScopeImmutable()
    {
      return self()->isImmutable( QStringLiteral( "defaultAttributeScope" ) );
    }

    /**
      Set Default Operation Scope
    */
    static
    void setDefaultOperationScope( Uml::Visibility::Enum v )
    {
      if (!self()->isDefaultOperationScopeImmutable())
        self()->mDefaultOperationScope = v;
    }

    /**
      Get Default Operation Scope
    */
    static
    Uml::Visibility::Enum defaultOperationScope()
    {
      return static_cast<Uml::Visibility::Enum>(self()->mDefaultOperationScope);
    }

    /**
      Is Default Operation Scope Immutable
    */
    static
    bool isDefaultOperationScopeImmutable()
    {
      return self()->isImmutable( QStringLiteral( "defaultOperationScope" ) );
    }

    /**
      Set Height
    */
    static
    void setHeight( int v )
    {

      if (v > 100)
      {
        qDebug() << "setHeight: value " << v << " is greater than the maximum value of 100";
        v = 100;
      }

      if (!self()->isHeightImmutable())
        self()->mHeight = v;
    }

    /**
      Get Height
    */
    static
    int height()
    {
      return self()->mHeight;
    }

    /**
      Is Height Immutable
    */
    static
    bool isHeightImmutable()
    {
      return self()->isImmutable( QStringLiteral( "height" ) );
    }

    /**
      Set Width
    */
    static
    void setWidth( int v )
    {

      if (v > 100)
      {
        qDebug() << "setWidth: value " << v << " is greater than the maximum value of 100";
        v = 100;
      }

      if (!self()->isWidthImmutable())
        self()->mWidth = v;
    }

    /**
      Get Width
    */
    static
    int width()
    {
      return self()->mWidth;
    }

    /**
      Is Width Immutable
    */
    static
    bool isWidthImmutable()
    {
      return self()->isImmutable( QStringLiteral( "width" ) );
    }

    /**
      Set Show Hidden Blocks
    */
    static
    void setShowHiddenBlocks( bool v )
    {
      if (!self()->isShowHiddenBlocksImmutable())
        self()->mShowHiddenBlocks = v;
    }

    /**
      Get Show Hidden Blocks
    */
    static
    bool showHiddenBlocks()
    {
      return self()->mShowHiddenBlocks;
    }

    /**
      Is Show Hidden Blocks Immutable
    */
    static
    bool isShowHiddenBlocksImmutable()
    {
      return self()->isImmutable( QStringLiteral( "showHiddenBlocks" ) );
    }

    /**
      Set Highlight Blocks
    */
    static
    void setBlocksAreHighlighted( bool v )
    {
      if (!self()->isBlocksAreHighlightedImmutable())
        self()->mBlocksAreHighlighted = v;
    }

    /**
      Get Highlight Blocks
    */
    static
    bool blocksAreHighlighted()
    {
      return self()->mBlocksAreHighlighted;
    }

    /**
      Is Highlight Blocks Immutable
    */
    static
    bool isBlocksAreHighlightedImmutable()
    {
      return self()->isImmutable( QStringLiteral( "blocksAreHighlighted" ) );
    }

    /**
      Set Font
    */
    static
    void setCodeViewerFont( const QFont & v )
    {
      if (!self()->isCodeViewerFontImmutable())
        self()->mCodeViewerFont = v;
    }

    /**
      Get Font
    */
    static
    QFont codeViewerFont()
    {
      return self()->mCodeViewerFont;
    }

    /**
      Is Font Immutable
    */
    static
    bool isCodeViewerFontImmutable()
    {
      return self()->isImmutable( QStringLiteral( "codeViewerFont" ) );
    }

    /**
      Set Paper Color
    */
    static
    void setPaperColor( const QColor & v )
    {
      if (!self()->isPaperColorImmutable())
        self()->mPaperColor = v;
    }

    /**
      Get Paper Color
    */
    static
    QColor paperColor()
    {
      return self()->mPaperColor;
    }

    /**
      Is Paper Color Immutable
    */
    static
    bool isPaperColorImmutable()
    {
      return self()->isImmutable( QStringLiteral( "paperColor" ) );
    }

    /**
      Set Font Color
    */
    static
    void setFontColor( const QColor & v )
    {
      if (!self()->isFontColorImmutable())
        self()->mFontColor = v;
    }

    /**
      Get Font Color
    */
    static
    QColor fontColor()
    {
      return self()->mFontColor;
    }

    /**
      Is Font Color Immutable
    */
    static
    bool isFontColorImmutable()
    {
      return self()->isImmutable( QStringLiteral( "fontColor" ) );
    }

    /**
      Set Selected Color
    */
    static
    void setSelectedColor( const QColor & v )
    {
      if (!self()->isSelectedColorImmutable())
        self()->mSelectedColor = v;
    }

    /**
      Get Selected Color
    */
    static
    QColor selectedColor()
    {
      return self()->mSelectedColor;
    }

    /**
      Is Selected Color Immutable
    */
    static
    bool isSelectedColorImmutable()
    {
      return self()->isImmutable( QStringLiteral( "selectedColor" ) );
    }

    /**
      Set Edit Block Color
    */
    static
    void setEditBlockColor( const QColor & v )
    {
      if (!self()->isEditBlockColorImmutable())
        self()->mEditBlockColor = v;
    }

    /**
      Get Edit Block Color
    */
    static
    QColor editBlockColor()
    {
      return self()->mEditBlockColor;
    }

    /**
      Is Edit Block Color Immutable
    */
    static
    bool isEditBlockColorImmutable()
    {
      return self()->isImmutable( QStringLiteral( "editBlockColor" ) );
    }

    /**
      Set Non Edit Block Color
    */
    static
    void setNonEditBlockColor( const QColor & v )
    {
      if (!self()->isNonEditBlockColorImmutable())
        self()->mNonEditBlockColor = v;
    }

    /**
      Get Non Edit Block Color
    */
    static
    QColor nonEditBlockColor()
    {
      return self()->mNonEditBlockColor;
    }

    /**
      Is Non Edit Block Color Immutable
    */
    static
    bool isNonEditBlockColorImmutable()
    {
      return self()->isImmutable( QStringLiteral( "nonEditBlockColor" ) );
    }

    /**
      Set UML Object Color
    */
    static
    void setUmlObjectColor( const QColor & v )
    {
      if (!self()->isUmlObjectColorImmutable())
        self()->mUmlObjectColor = v;
    }

    /**
      Get UML Object Color
    */
    static
    QColor umlObjectColor()
    {
      return self()->mUmlObjectColor;
    }

    /**
      Is UML Object Color Immutable
    */
    static
    bool isUmlObjectColorImmutable()
    {
      return self()->isImmutable( QStringLiteral( "umlObjectColor" ) );
    }

    /**
      Set Hidden Color
    */
    static
    void setHiddenColor( const QColor & v )
    {
      if (!self()->isHiddenColorImmutable())
        self()->mHiddenColor = v;
    }

    /**
      Get Hidden Color
    */
    static
    QColor hiddenColor()
    {
      return self()->mHiddenColor;
    }

    /**
      Is Hidden Color Immutable
    */
    static
    bool isHiddenColorImmutable()
    {
      return self()->isImmutable( QStringLiteral( "hiddenColor" ) );
    }

    /**
      Set Create Artifacts for imported files
    */
    static
    void setCreateArtifacts( bool v )
    {
      if (!self()->isCreateArtifactsImmutable())
        self()->mCreateArtifacts = v;
    }

    /**
      Get Create Artifacts for imported files
    */
    static
    bool createArtifacts()
    {
      return self()->mCreateArtifacts;
    }

    /**
      Is Create Artifacts for imported files Immutable
    */
    static
    bool isCreateArtifactsImmutable()
    {
      return self()->isImmutable( QStringLiteral( "createArtifacts" ) );
    }

    /**
      Set Resolve dependencies
    */
    static
    void setResolveDependencies( bool v )
    {
      if (!self()->isResolveDependenciesImmutable())
        self()->mResolveDependencies = v;
    }

    /**
      Get Resolve dependencies
    */
    static
    bool resolveDependencies()
    {
      return self()->mResolveDependencies;
    }

    /**
      Is Resolve dependencies Immutable
    */
    static
    bool isResolveDependenciesImmutable()
    {
      return self()->isImmutable( QStringLiteral( "resolveDependencies" ) );
    }

    /**
      Set Support C++11 standard
    */
    static
    void setSupportCPP11( bool v )
    {
      if (!self()->isSupportCPP11Immutable())
        self()->mSupportCPP11 = v;
    }

    /**
      Get Support C++11 standard
    */
    static
    bool supportCPP11()
    {
      return self()->mSupportCPP11;
    }

    /**
      Is Support C++11 standard Immutable
    */
    static
    bool isSupportCPP11Immutable()
    {
      return self()->isImmutable( QStringLiteral( "supportCPP11" ) );
    }

    /**
      Set Auto Generate Empty Constructors
    */
    static
    void setAutoGenEmptyConstructors( bool v )
    {
      if (!self()->isAutoGenEmptyConstructorsImmutable())
        self()->mAutoGenEmptyConstructors = v;
    }

    /**
      Get Auto Generate Empty Constructors
    */
    static
    bool autoGenEmptyConstructors()
    {
      return self()->mAutoGenEmptyConstructors;
    }

    /**
      Is Auto Generate Empty Constructors Immutable
    */
    static
    bool isAutoGenEmptyConstructorsImmutable()
    {
      return self()->isImmutable( QStringLiteral( "autoGenEmptyConstructors" ) );
    }

    /**
      Set Comment Style
    */
    static
    void setCommentStyle( CodeGenerationPolicy::CommentStyle v )
    {
      if (!self()->isCommentStyleImmutable())
        self()->mCommentStyle = v;
    }

    /**
      Get Comment Style
    */
    static
    CodeGenerationPolicy::CommentStyle commentStyle()
    {
      return static_cast<CodeGenerationPolicy::CommentStyle>(self()->mCommentStyle);
    }

    /**
      Is Comment Style Immutable
    */
    static
    bool isCommentStyleImmutable()
    {
      return self()->isImmutable( QStringLiteral( "commentStyle" ) );
    }

    /**
      Set Default Association Field Scope
    */
    static
    void setDefaultAssocFieldScope( Uml::Visibility::Enum v )
    {
      if (!self()->isDefaultAssocFieldScopeImmutable())
        self()->mDefaultAssocFieldScope = v;
    }

    /**
      Get Default Association Field Scope
    */
    static
    Uml::Visibility::Enum defaultAssocFieldScope()
    {
      return static_cast<Uml::Visibility::Enum>(self()->mDefaultAssocFieldScope);
    }

    /**
      Is Default Association Field Scope Immutable
    */
    static
    bool isDefaultAssocFieldScopeImmutable()
    {
      return self()->isImmutable( QStringLiteral( "defaultAssocFieldScope" ) );
    }

    /**
      Set Default Attribute Accessor Scope
    */
    static
    void setDefaultAttributeAccessorScope( Uml::Visibility::Enum v )
    {
      if (!self()->isDefaultAttributeAccessorScopeImmutable())
        self()->mDefaultAttributeAccessorScope = v;
    }

    /**
      Get Default Attribute Accessor Scope
    */
    static
    Uml::Visibility::Enum defaultAttributeAccessorScope()
    {
      return static_cast<Uml::Visibility::Enum>(self()->mDefaultAttributeAccessorScope);
    }

    /**
      Is Default Attribute Accessor Scope Immutable
    */
    static
    bool isDefaultAttributeAccessorScopeImmutable()
    {
      return self()->isImmutable( QStringLiteral( "defaultAttributeAccessorScope" ) );
    }

    /**
      Set Force Documentation
    */
    static
    void setForceDoc( bool v )
    {
      if (!self()->isForceDocImmutable())
        self()->mForceDoc = v;
    }

    /**
      Get Force Documentation
    */
    static
    bool forceDoc()
    {
      return self()->mForceDoc;
    }

    /**
      Is Force Documentation Immutable
    */
    static
    bool isForceDocImmutable()
    {
      return self()->isImmutable( QStringLiteral( "forceDoc" ) );
    }

    /**
      Set Section Comment Policy
    */
    static
    void setWriteSectionComments( CodeGenerationPolicy::WriteSectionCommentsPolicy v )
    {
      if (!self()->isWriteSectionCommentsImmutable())
        self()->mWriteSectionComments = v;
    }

    /**
      Get Section Comment Policy
    */
    static
    CodeGenerationPolicy::WriteSectionCommentsPolicy writeSectionComments()
    {
      return static_cast<CodeGenerationPolicy::WriteSectionCommentsPolicy>(self()->mWriteSectionComments);
    }

    /**
      Is Section Comment Policy Immutable
    */
    static
    bool isWriteSectionCommentsImmutable()
    {
      return self()->isImmutable( QStringLiteral( "writeSectionComments" ) );
    }

    /**
      Set Headings Directory
    */
    static
    void setHeadingsDirectory( const QString & v )
    {
      if (!self()->isHeadingsDirectoryImmutable())
        self()->mHeadingsDirectory = v;
    }

    /**
      Get Headings Directory
    */
    static
    QString headingsDirectory()
    {
      return self()->mHeadingsDirectory;
    }

    /**
      Is Headings Directory Immutable
    */
    static
    bool isHeadingsDirectoryImmutable()
    {
      return self()->isImmutable( QStringLiteral( "headingsDirectory" ) );
    }

    /**
      Set Include headings
    */
    static
    void setIncludeHeadings( bool v )
    {
      if (!self()->isIncludeHeadingsImmutable())
        self()->mIncludeHeadings = v;
    }

    /**
      Get Include headings
    */
    static
    bool includeHeadings()
    {
      return self()->mIncludeHeadings;
    }

    /**
      Is Include headings Immutable
    */
    static
    bool isIncludeHeadingsImmutable()
    {
      return self()->isImmutable( QStringLiteral( "includeHeadings" ) );
    }

    /**
      Set Indentation Amount
    */
    static
    void setIndentationAmount( int v )
    {

      if (v > 10)
      {
        qDebug() << "setIndentationAmount: value " << v << " is greater than the maximum value of 10";
        v = 10;
      }

      if (!self()->isIndentationAmountImmutable())
        self()->mIndentationAmount = v;
    }

    /**
      Get Indentation Amount
    */
    static
    int indentationAmount()
    {
      return self()->mIndentationAmount;
    }

    /**
      Is Indentation Amount Immutable
    */
    static
    bool isIndentationAmountImmutable()
    {
      return self()->isImmutable( QStringLiteral( "indentationAmount" ) );
    }

    /**
      Set Indentation Type
    */
    static
    void setIndentationType( CodeGenerationPolicy::IndentationType v )
    {
      if (!self()->isIndentationTypeImmutable())
        self()->mIndentationType = v;
    }

    /**
      Get Indentation Type
    */
    static
    CodeGenerationPolicy::IndentationType indentationType()
    {
      return static_cast<CodeGenerationPolicy::IndentationType>(self()->mIndentationType);
    }

    /**
      Is Indentation Type Immutable
    */
    static
    bool isIndentationTypeImmutable()
    {
      return self()->isImmutable( QStringLiteral( "indentationType" ) );
    }

    /**
      Set Line Ending Type
    */
    static
    void setLineEndingType( CodeGenerationPolicy::NewLineType v )
    {
      if (!self()->isLineEndingTypeImmutable())
        self()->mLineEndingType = v;
    }

    /**
      Get Line Ending Type
    */
    static
    CodeGenerationPolicy::NewLineType lineEndingType()
    {
      return static_cast<CodeGenerationPolicy::NewLineType>(self()->mLineEndingType);
    }

    /**
      Is Line Ending Type Immutable
    */
    static
    bool isLineEndingTypeImmutable()
    {
      return self()->isImmutable( QStringLiteral( "lineEndingType" ) );
    }

    /**
      Set Modifier Name Policy
    */
    static
    void setModnamePolicy( CodeGenerationPolicy::ModifyNamePolicy v )
    {
      if (!self()->isModnamePolicyImmutable())
        self()->mModnamePolicy = v;
    }

    /**
      Get Modifier Name Policy
    */
    static
    CodeGenerationPolicy::ModifyNamePolicy modnamePolicy()
    {
      return static_cast<CodeGenerationPolicy::ModifyNamePolicy>(self()->mModnamePolicy);
    }

    /**
      Is Modifier Name Policy Immutable
    */
    static
    bool isModnamePolicyImmutable()
    {
      return self()->isImmutable( QStringLiteral( "modnamePolicy" ) );
    }

    /**
      Set Output Directory
    */
    static
    void setOutputDirectory( const QString & v )
    {
      if (!self()->isOutputDirectoryImmutable())
        self()->mOutputDirectory = v;
    }

    /**
      Get Output Directory
    */
    static
    QString outputDirectory()
    {
      return self()->mOutputDirectory;
    }

    /**
      Is Output Directory Immutable
    */
    static
    bool isOutputDirectoryImmutable()
    {
      return self()->isImmutable( QStringLiteral( "outputDirectory" ) );
    }

    /**
      Set Overwrite Policy
    */
    static
    void setOverwritePolicy( CodeGenerationPolicy::OverwritePolicy v )
    {
      if (!self()->isOverwritePolicyImmutable())
        self()->mOverwritePolicy = v;
    }

    /**
      Get Overwrite Policy
    */
    static
    CodeGenerationPolicy::OverwritePolicy overwritePolicy()
    {
      return static_cast<CodeGenerationPolicy::OverwritePolicy>(self()->mOverwritePolicy);
    }

    /**
      Is Overwrite Policy Immutable
    */
    static
    bool isOverwritePolicyImmutable()
    {
      return self()->isImmutable( QStringLiteral( "overwritePolicy" ) );
    }

    /**
      Set Auto Generate Accessors
    */
    static
    void setAutoGenAccessors( bool v )
    {
      if (!self()->isAutoGenAccessorsImmutable())
        self()->mAutoGenAccessors = v;
    }

    /**
      Get Auto Generate Accessors
    */
    static
    bool autoGenAccessors()
    {
      return self()->mAutoGenAccessors;
    }

    /**
      Is Auto Generate Accessors Immutable
    */
    static
    bool isAutoGenAccessorsImmutable()
    {
      return self()->isImmutable( QStringLiteral( "autoGenAccessors" ) );
    }

    /**
      Set Class member prefix
    */
    static
    void setClassMemberPrefix( const QString & v )
    {
      if (!self()->isClassMemberPrefixImmutable())
        self()->mClassMemberPrefix = v;
    }

    /**
      Get Class member prefix
    */
    static
    QString classMemberPrefix()
    {
      return self()->mClassMemberPrefix;
    }

    /**
      Is Class member prefix Immutable
    */
    static
    bool isClassMemberPrefixImmutable()
    {
      return self()->isImmutable( QStringLiteral( "classMemberPrefix" ) );
    }

    /**
      Set Inline Accessors
    */
    static
    void setInlineAccessors( bool v )
    {
      if (!self()->isInlineAccessorsImmutable())
        self()->mInlineAccessors = v;
    }

    /**
      Get Inline Accessors
    */
    static
    bool inlineAccessors()
    {
      return self()->mInlineAccessors;
    }

    /**
      Is Inline Accessors Immutable
    */
    static
    bool isInlineAccessorsImmutable()
    {
      return self()->isImmutable( QStringLiteral( "inlineAccessors" ) );
    }

    /**
      Set Inline operations
    */
    static
    void setInlineOps( bool v )
    {
      if (!self()->isInlineOpsImmutable())
        self()->mInlineOps = v;
    }

    /**
      Get Inline operations
    */
    static
    bool inlineOps()
    {
      return self()->mInlineOps;
    }

    /**
      Is Inline operations Immutable
    */
    static
    bool isInlineOpsImmutable()
    {
      return self()->isImmutable( QStringLiteral( "inlineOps" ) );
    }

    /**
      Set Package is namespace
    */
    static
    void setPackageIsNamespace( bool v )
    {
      if (!self()->isPackageIsNamespaceImmutable())
        self()->mPackageIsNamespace = v;
    }

    /**
      Get Package is namespace
    */
    static
    bool packageIsNamespace()
    {
      return self()->mPackageIsNamespace;
    }

    /**
      Is Package is namespace Immutable
    */
    static
    bool isPackageIsNamespaceImmutable()
    {
      return self()->isImmutable( QStringLiteral( "packageIsNamespace" ) );
    }

    /**
      Set Public Accessors
    */
    static
    void setPublicAccessors( bool v )
    {
      if (!self()->isPublicAccessorsImmutable())
        self()->mPublicAccessors = v;
    }

    /**
      Get Public Accessors
    */
    static
    bool publicAccessors()
    {
      return self()->mPublicAccessors;
    }

    /**
      Is Public Accessors Immutable
    */
    static
    bool isPublicAccessorsImmutable()
    {
      return self()->isImmutable( QStringLiteral( "publicAccessors" ) );
    }

    /**
      Set String Class Name
    */
    static
    void setStringClassName( const QString & v )
    {
      if (!self()->isStringClassNameImmutable())
        self()->mStringClassName = v;
    }

    /**
      Get String Class Name
    */
    static
    QString stringClassName()
    {
      return self()->mStringClassName;
    }

    /**
      Is String Class Name Immutable
    */
    static
    bool isStringClassNameImmutable()
    {
      return self()->isImmutable( QStringLiteral( "stringClassName" ) );
    }

    /**
      Set String Class Name Include
    */
    static
    void setStringClassNameInclude( const QString & v )
    {
      if (!self()->isStringClassNameIncludeImmutable())
        self()->mStringClassNameInclude = v;
    }

    /**
      Get String Class Name Include
    */
    static
    QString stringClassNameInclude()
    {
      return self()->mStringClassNameInclude;
    }

    /**
      Is String Class Name Include Immutable
    */
    static
    bool isStringClassNameIncludeImmutable()
    {
      return self()->isImmutable( QStringLiteral( "stringClassNameInclude" ) );
    }

    /**
      Set String Include is Global
    */
    static
    void setStringIncludeIsGlobal( bool v )
    {
      if (!self()->isStringIncludeIsGlobalImmutable())
        self()->mStringIncludeIsGlobal = v;
    }

    /**
      Get String Include is Global
    */
    static
    bool stringIncludeIsGlobal()
    {
      return self()->mStringIncludeIsGlobal;
    }

    /**
      Is String Include is Global Immutable
    */
    static
    bool isStringIncludeIsGlobalImmutable()
    {
      return self()->isImmutable( QStringLiteral( "stringIncludeIsGlobal" ) );
    }

    /**
      Set Vector Class Name
    */
    static
    void setVectorClassName( const QString & v )
    {
      if (!self()->isVectorClassNameImmutable())
        self()->mVectorClassName = v;
    }

    /**
      Get Vector Class Name
    */
    static
    QString vectorClassName()
    {
      return self()->mVectorClassName;
    }

    /**
      Is Vector Class Name Immutable
    */
    static
    bool isVectorClassNameImmutable()
    {
      return self()->isImmutable( QStringLiteral( "vectorClassName" ) );
    }

    /**
      Set Vector Class Name Include
    */
    static
    void setVectorClassNameInclude( const QString & v )
    {
      if (!self()->isVectorClassNameIncludeImmutable())
        self()->mVectorClassNameInclude = v;
    }

    /**
      Get Vector Class Name Include
    */
    static
    QString vectorClassNameInclude()
    {
      return self()->mVectorClassNameInclude;
    }

    /**
      Is Vector Class Name Include Immutable
    */
    static
    bool isVectorClassNameIncludeImmutable()
    {
      return self()->isImmutable( QStringLiteral( "vectorClassNameInclude" ) );
    }

    /**
      Set Vector include is global
    */
    static
    void setVectorIncludeIsGlobal( bool v )
    {
      if (!self()->isVectorIncludeIsGlobalImmutable())
        self()->mVectorIncludeIsGlobal = v;
    }

    /**
      Get Vector include is global
    */
    static
    bool vectorIncludeIsGlobal()
    {
      return self()->mVectorIncludeIsGlobal;
    }

    /**
      Is Vector include is global Immutable
    */
    static
    bool isVectorIncludeIsGlobalImmutable()
    {
      return self()->isImmutable( QStringLiteral( "vectorIncludeIsGlobal" ) );
    }

    /**
      Set Virtual Destructors
    */
    static
    void setVirtualDestructors( bool v )
    {
      if (!self()->isVirtualDestructorsImmutable())
        self()->mVirtualDestructors = v;
    }

    /**
      Get Virtual Destructors
    */
    static
    bool virtualDestructors()
    {
      return self()->mVirtualDestructors;
    }

    /**
      Is Virtual Destructors Immutable
    */
    static
    bool isVirtualDestructorsImmutable()
    {
      return self()->isImmutable( QStringLiteral( "virtualDestructors" ) );
    }

    /**
      Set Getters with 'get' prefix
    */
    static
    void setGetterWithGetPrefix( bool v )
    {
      if (!self()->isGetterWithGetPrefixImmutable())
        self()->mGetterWithGetPrefix = v;
    }

    /**
      Get Getters with 'get' prefix
    */
    static
    bool getterWithGetPrefix()
    {
      return self()->mGetterWithGetPrefix;
    }

    /**
      Is Getters with 'get' prefix Immutable
    */
    static
    bool isGetterWithGetPrefixImmutable()
    {
      return self()->isImmutable( QStringLiteral( "getterWithGetPrefix" ) );
    }

    /**
      Set Remove prefix '[a-zA-Z]_' from accessor methods
    */
    static
    void setRemovePrefixFromAccessorMethods( bool v )
    {
      if (!self()->isRemovePrefixFromAccessorMethodsImmutable())
        self()->mRemovePrefixFromAccessorMethods = v;
    }

    /**
      Get Remove prefix '[a-zA-Z]_' from accessor methods
    */
    static
    bool removePrefixFromAccessorMethods()
    {
      return self()->mRemovePrefixFromAccessorMethods;
    }

    /**
      Is Remove prefix '[a-zA-Z]_' from accessor methods Immutable
    */
    static
    bool isRemovePrefixFromAccessorMethodsImmutable()
    {
      return self()->isImmutable( QStringLiteral( "removePrefixFromAccessorMethods" ) );
    }

    /**
      Set Accessor methods start with capital letters
    */
    static
    void setAccessorMethodsStartWithUpperCase( bool v )
    {
      if (!self()->isAccessorMethodsStartWithUpperCaseImmutable())
        self()->mAccessorMethodsStartWithUpperCase = v;
    }

    /**
      Get Accessor methods start with capital letters
    */
    static
    bool accessorMethodsStartWithUpperCase()
    {
      return self()->mAccessorMethodsStartWithUpperCase;
    }

    /**
      Is Accessor methods start with capital letters Immutable
    */
    static
    bool isAccessorMethodsStartWithUpperCaseImmutable()
    {
      return self()->isImmutable( QStringLiteral( "accessorMethodsStartWithUpperCase" ) );
    }

    /**
      Set Documentation tags
    */
    static
    void setDocToolTag( const QString & v )
    {
      if (!self()->isDocToolTagImmutable())
        self()->mDocToolTag = v;
    }

    /**
      Get Documentation tags
    */
    static
    QString docToolTag()
    {
      return self()->mDocToolTag;
    }

    /**
      Is Documentation tags Immutable
    */
    static
    bool isDocToolTagImmutable()
    {
      return self()->isImmutable( QStringLiteral( "docToolTag" ) );
    }

    /**
      Set Auto Generate Attribute Accessors ( D )
    */
    static
    void setAutoGenerateAttributeAccessorsD( bool v )
    {
      if (!self()->isAutoGenerateAttributeAccessorsDImmutable())
        self()->mAutoGenerateAttributeAccessorsD = v;
    }

    /**
      Get Auto Generate Attribute Accessors ( D )
    */
    static
    bool autoGenerateAttributeAccessorsD()
    {
      return self()->mAutoGenerateAttributeAccessorsD;
    }

    /**
      Is Auto Generate Attribute Accessors ( D ) Immutable
    */
    static
    bool isAutoGenerateAttributeAccessorsDImmutable()
    {
      return self()->isImmutable( QStringLiteral( "autoGenerateAttributeAccessorsD" ) );
    }

    /**
      Set Auto Generate Assoc Accessors ( D )
    */
    static
    void setAutoGenerateAssocAccessorsD( bool v )
    {
      if (!self()->isAutoGenerateAssocAccessorsDImmutable())
        self()->mAutoGenerateAssocAccessorsD = v;
    }

    /**
      Get Auto Generate Assoc Accessors ( D )
    */
    static
    bool autoGenerateAssocAccessorsD()
    {
      return self()->mAutoGenerateAssocAccessorsD;
    }

    /**
      Is Auto Generate Assoc Accessors ( D ) Immutable
    */
    static
    bool isAutoGenerateAssocAccessorsDImmutable()
    {
      return self()->isImmutable( QStringLiteral( "autoGenerateAssocAccessorsD" ) );
    }

    /**
      Set Build ANT Document (D)
    */
    static
    void setBuildANTDocumentD( bool v )
    {
      if (!self()->isBuildANTDocumentDImmutable())
        self()->mBuildANTDocumentD = v;
    }

    /**
      Get Build ANT Document (D)
    */
    static
    bool buildANTDocumentD()
    {
      return self()->mBuildANTDocumentD;
    }

    /**
      Is Build ANT Document (D) Immutable
    */
    static
    bool isBuildANTDocumentDImmutable()
    {
      return self()->isImmutable( QStringLiteral( "buildANTDocumentD" ) );
    }

    /**
      Set Auto Generate Attribute Accessors (Java)
    */
    static
    void setAutoGenerateAttributeAccessorsJava( bool v )
    {
      if (!self()->isAutoGenerateAttributeAccessorsJavaImmutable())
        self()->mAutoGenerateAttributeAccessorsJava = v;
    }

    /**
      Get Auto Generate Attribute Accessors (Java)
    */
    static
    bool autoGenerateAttributeAccessorsJava()
    {
      return self()->mAutoGenerateAttributeAccessorsJava;
    }

    /**
      Is Auto Generate Attribute Accessors (Java) Immutable
    */
    static
    bool isAutoGenerateAttributeAccessorsJavaImmutable()
    {
      return self()->isImmutable( QStringLiteral( "autoGenerateAttributeAccessorsJava" ) );
    }

    /**
      Set Auto Generate Assoc Accessors (Java)
    */
    static
    void setAutoGenerateAssocAccessorsJava( bool v )
    {
      if (!self()->isAutoGenerateAssocAccessorsJavaImmutable())
        self()->mAutoGenerateAssocAccessorsJava = v;
    }

    /**
      Get Auto Generate Assoc Accessors (Java)
    */
    static
    bool autoGenerateAssocAccessorsJava()
    {
      return self()->mAutoGenerateAssocAccessorsJava;
    }

    /**
      Is Auto Generate Assoc Accessors (Java) Immutable
    */
    static
    bool isAutoGenerateAssocAccessorsJavaImmutable()
    {
      return self()->isImmutable( QStringLiteral( "autoGenerateAssocAccessorsJava" ) );
    }

    /**
      Set Build ANT Document (Java)
    */
    static
    void setBuildANTDocumentJava( bool v )
    {
      if (!self()->isBuildANTDocumentJavaImmutable())
        self()->mBuildANTDocumentJava = v;
    }

    /**
      Get Build ANT Document (Java)
    */
    static
    bool buildANTDocumentJava()
    {
      return self()->mBuildANTDocumentJava;
    }

    /**
      Is Build ANT Document (Java) Immutable
    */
    static
    bool isBuildANTDocumentJavaImmutable()
    {
      return self()->isImmutable( QStringLiteral( "buildANTDocumentJava" ) );
    }

    /**
      Set Auto Generate Attribute Accessors (Ruby)
    */
    static
    void setAutoGenerateAttributeAccessorsRuby( bool v )
    {
      if (!self()->isAutoGenerateAttributeAccessorsRubyImmutable())
        self()->mAutoGenerateAttributeAccessorsRuby = v;
    }

    /**
      Get Auto Generate Attribute Accessors (Ruby)
    */
    static
    bool autoGenerateAttributeAccessorsRuby()
    {
      return self()->mAutoGenerateAttributeAccessorsRuby;
    }

    /**
      Is Auto Generate Attribute Accessors (Ruby) Immutable
    */
    static
    bool isAutoGenerateAttributeAccessorsRubyImmutable()
    {
      return self()->isImmutable( QStringLiteral( "autoGenerateAttributeAccessorsRuby" ) );
    }

    /**
      Set Auto Generate Assoc Accessors (Ruby)
    */
    static
    void setAutoGenerateAssocAccessorsRuby( bool v )
    {
      if (!self()->isAutoGenerateAssocAccessorsRubyImmutable())
        self()->mAutoGenerateAssocAccessorsRuby = v;
    }

    /**
      Get Auto Generate Assoc Accessors (Ruby)
    */
    static
    bool autoGenerateAssocAccessorsRuby()
    {
      return self()->mAutoGenerateAssocAccessorsRuby;
    }

    /**
      Is Auto Generate Assoc Accessors (Ruby) Immutable
    */
    static
    bool isAutoGenerateAssocAccessorsRubyImmutable()
    {
      return self()->isImmutable( QStringLiteral( "autoGenerateAssocAccessorsRuby" ) );
    }

    /**
      Set Automatic Dot Path
    */
    static
    void setAutoDotPath( bool v )
    {
      if (!self()->isAutoDotPathImmutable())
        self()->mAutoDotPath = v;
    }

    /**
      Get Automatic Dot Path
    */
    static
    bool autoDotPath()
    {
      return self()->mAutoDotPath;
    }

    /**
      Is Automatic Dot Path Immutable
    */
    static
    bool isAutoDotPathImmutable()
    {
      return self()->isImmutable( QStringLiteral( "autoDotPath" ) );
    }

    /**
      Set Dot Path
    */
    static
    void setDotPath( const QString & v )
    {
      if (!self()->isDotPathImmutable())
        self()->mDotPath = v;
    }

    /**
      Get Dot Path
    */
    static
    QString dotPath()
    {
      return self()->mDotPath;
    }

    /**
      Is Dot Path Immutable
    */
    static
    bool isDotPathImmutable()
    {
      return self()->isImmutable( QStringLiteral( "dotPath" ) );
    }

    /**
      Set Show Export Layout
    */
    static
    void setShowExportLayout( bool v )
    {
      if (!self()->isShowExportLayoutImmutable())
        self()->mShowExportLayout = v;
    }

    /**
      Get Show Export Layout
    */
    static
    bool showExportLayout()
    {
      return self()->mShowExportLayout;
    }

    /**
      Is Show Export Layout Immutable
    */
    static
    bool isShowExportLayoutImmutable()
    {
      return self()->isImmutable( QStringLiteral( "showExportLayout" ) );
    }

  protected:
    UmbrelloSettings();
    friend class UmbrelloSettingsHelper;


    // General Options
    QSize mGeometry;
    QString mImageMimeType;
    bool mUndo;
    bool mTabdiagrams;
    bool mNewcodegen;
    int mLayoutType;
    bool mFooterPrinting;
    bool mAutosave;
    int mTime;
    int mAutosavetime;
    QString mAutosavesuffix;
    bool mLoadlast;
    int mDiagram;
    int mDefaultLanguage;
    QString mLastFile;
    bool mUml2;
    bool mShowDebugWindows;

    // UI Options
    bool mUseFillColor;
    QColor mFillColor;
    QColor mLineColor;
    uint mLineWidth;
    QColor mTextColor;
    bool mShowDocWindow;
    QFont mUiFont;
    QColor mBackgroundColor;
    bool mUseBackgroundColor;
    QColor mGridDotColor;
    bool mUseAlignmentGuides;
    bool mRightToLeftUI;

    // Class Options
    bool mShowVisibility;
    bool mShowAtts;
    bool mShowOps;
    bool mShowPackage;
    int mShowStereoType;
    bool mShowAttribAssocs;
    bool mShowPublicOnly;
    bool mShowAttSig;
    bool mShowOpSig;
    int mDefaultAttributeScope;
    int mDefaultOperationScope;

    // Code Viewer Options
    int mHeight;
    int mWidth;
    bool mShowHiddenBlocks;
    bool mBlocksAreHighlighted;
    QFont mCodeViewerFont;
    QColor mPaperColor;
    QColor mFontColor;
    QColor mSelectedColor;
    QColor mEditBlockColor;
    QColor mNonEditBlockColor;
    QColor mUmlObjectColor;
    QColor mHiddenColor;

    // Code Importer
    bool mCreateArtifacts;
    bool mResolveDependencies;
    bool mSupportCPP11;

    // Code Generation
    bool mAutoGenEmptyConstructors;
    int mCommentStyle;
    int mDefaultAssocFieldScope;
    int mDefaultAttributeAccessorScope;
    bool mForceDoc;
    int mWriteSectionComments;
    QString mHeadingsDirectory;
    bool mIncludeHeadings;
    int mIndentationAmount;
    int mIndentationType;
    int mLineEndingType;
    int mModnamePolicy;
    QString mOutputDirectory;
    int mOverwritePolicy;

    // CPP Code Generation
    bool mAutoGenAccessors;
    QString mClassMemberPrefix;
    bool mInlineAccessors;
    bool mInlineOps;
    bool mPackageIsNamespace;
    bool mPublicAccessors;
    QString mStringClassName;
    QString mStringClassNameInclude;
    bool mStringIncludeIsGlobal;
    QString mVectorClassName;
    QString mVectorClassNameInclude;
    bool mVectorIncludeIsGlobal;
    bool mVirtualDestructors;
    bool mGetterWithGetPrefix;
    bool mRemovePrefixFromAccessorMethods;
    bool mAccessorMethodsStartWithUpperCase;
    QString mDocToolTag;

    // D Code Generation
    bool mAutoGenerateAttributeAccessorsD;
    bool mAutoGenerateAssocAccessorsD;
    bool mBuildANTDocumentD;

    // Java Code Generation
    bool mAutoGenerateAttributeAccessorsJava;
    bool mAutoGenerateAssocAccessorsJava;
    bool mBuildANTDocumentJava;

    // Ruby Code Generation
    bool mAutoGenerateAttributeAccessorsRuby;
    bool mAutoGenerateAssocAccessorsRuby;

    // Auto Layout
    bool mAutoDotPath;
    QString mDotPath;
    bool mShowExportLayout;
};

#endif

