// This file is generated by kconfig_compiler_kf5 from breezesettingsdata.kcfg.
// All changes you do to this file will be lost.
#ifndef BREEZE_INTERNALSETTINGS_H
#define BREEZE_INTERNALSETTINGS_H

#include "breezecommon_export.h"

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

namespace Breeze {

class BREEZECOMMON_EXPORT InternalSettings : public KConfigSkeleton
{
  public:
    class EnumButtonIconStyle
    {
      public:
      enum type { StyleSystemIconTheme, StyleKite, StyleSuessigKite, StyleOxygen, StyleKlasse, StyleTraditional, StyleMetro, StyleFluent, StyleArk, StyleArkopal, StyleArkopalLeft, StyleKisweet, COUNT };
    };
    class EnumIconSize
    {
      public:
      enum type { IconTiny, IconVerySmall, IconSmall, IconSmallMedium, IconMedium, IconLargeMedium, IconLarge, IconVeryLarge, IconGiant, IconHumongous, COUNT };
    };
    class EnumSystemIconSize
    {
      public:
      enum type { SystemIcon8, SystemIcon12, SystemIcon14, SystemIcon16, SystemIcon18, SystemIcon20, SystemIcon22, SystemIcon24, SystemIcon32, SystemIcon48, COUNT };
    };
    class EnumBoldButtonIcons
    {
      public:
      enum type { BoldIconsBold, BoldIconsFine, BoldIconsHiDpiOnly, BoldIconsActive, BoldIconsActiveHiDpi, COUNT };
    };
    class EnumButtonShape
    {
      public:
      enum type { ShapeFullHeightRectangle, ShapeFullHeightRoundedRectangle, ShapeIntegratedRoundedRectangle, ShapeIntegratedRoundedRectangleGrouped, ShapeSmallCircle, ShapeSmallSquare, ShapeSmallRoundedSquare, COUNT };
    };
    class EnumButtonCornerRadius
    {
      public:
      enum type { SameAsWindow, Custom, COUNT };
    };
    class EnumButtonIconColors
    {
      public:
      enum type { TitleBarText, TitleBarTextNegativeClose, Accent, AccentNegativeClose, AccentTrafficLights, COUNT };
    };
    class EnumButtonIconColorsActive
    {
      public:
      enum type { Inactive, Active, COUNT };
      static const char* const enumToString[];
    };
    class EnumCloseButtonIconColor
    {
      public:
      enum type { AsSelected, NegativeWhenHoverPress, White, WhiteWhenHoverPress, COUNT };
    };
    class EnumCloseButtonIconColorActive
    {
      public:
      enum type { Inactive, Active, COUNT };
      static const char* const enumToString[];
    };
    class EnumOnPoorIconContrast
    {
      public:
      enum type { Nothing, BlackWhite, TitleBarBackground, COUNT };
    };
    class EnumOnPoorIconContrastActive
    {
      public:
      enum type { Inactive, Active, COUNT };
      static const char* const enumToString[];
    };
    class EnumPoorIconContrastThresholdActive
    {
      public:
      enum type { Inactive, Active, COUNT };
      static const char* const enumToString[];
    };
    class EnumButtonBackgroundColors
    {
      public:
      enum type { TitleBarText, TitleBarTextNegativeClose, Accent, AccentNegativeClose, AccentTrafficLights, COUNT };
    };
    class EnumButtonBackgroundColorsActive
    {
      public:
      enum type { Inactive, Active, COUNT };
      static const char* const enumToString[];
    };
    class EnumNegativeCloseBackgroundHoverPressActive
    {
      public:
      enum type { Inactive, Active, COUNT };
      static const char* const enumToString[];
    };
    class EnumUseHoverAccentActive
    {
      public:
      enum type { Inactive, Active, COUNT };
      static const char* const enumToString[];
    };
    class EnumAdjustBackgroundColorOnPoorContrastActive
    {
      public:
      enum type { Inactive, Active, COUNT };
      static const char* const enumToString[];
    };
    class EnumPoorBackgroundContrastThresholdActive
    {
      public:
      enum type { Inactive, Active, COUNT };
      static const char* const enumToString[];
    };
    class EnumButtonIconOpacityActive
    {
      public:
      enum type { Inactive, Active, COUNT };
      static const char* const enumToString[];
    };
    class EnumButtonBackgroundOpacityActive
    {
      public:
      enum type { Inactive, Active, COUNT };
      static const char* const enumToString[];
    };
    class EnumButtonOverrideColorsActiveButtonType
    {
      public:
      enum type { Menu, ApplicationMenu, OnAllDesktops, Minimize, Maximize, Close, ContextHelp, Shade, KeepBelow, KeepAbove, COUNT };
      static const char* const enumToString[];
    };
    class EnumButtonOverrideColorsInactiveButtonType
    {
      public:
      enum type { Menu, ApplicationMenu, OnAllDesktops, Minimize, Maximize, Close, ContextHelp, Shade, KeepBelow, KeepAbove, COUNT };
      static const char* const enumToString[];
    };
    class EnumButtonOverrideColorsLockStatesActive
    {
      public:
      enum type { Inactive, Active, COUNT };
      static const char* const enumToString[];
    };
    class EnumShowIconOnPressActive
    {
      public:
      enum type { Inactive, Active, COUNT };
      static const char* const enumToString[];
    };
    class EnumShowBackgroundOnPressActive
    {
      public:
      enum type { Inactive, Active, COUNT };
      static const char* const enumToString[];
    };
    class EnumShowOutlineOnPressActive
    {
      public:
      enum type { Inactive, Active, COUNT };
      static const char* const enumToString[];
    };
    class EnumShowIconOnHoverActive
    {
      public:
      enum type { Inactive, Active, COUNT };
      static const char* const enumToString[];
    };
    class EnumShowBackgroundOnHoverActive
    {
      public:
      enum type { Inactive, Active, COUNT };
      static const char* const enumToString[];
    };
    class EnumShowOutlineOnHoverActive
    {
      public:
      enum type { Inactive, Active, COUNT };
      static const char* const enumToString[];
    };
    class EnumShowIconNormallyActive
    {
      public:
      enum type { Inactive, Active, COUNT };
      static const char* const enumToString[];
    };
    class EnumShowBackgroundNormallyActive
    {
      public:
      enum type { Inactive, Active, COUNT };
      static const char* const enumToString[];
    };
    class EnumShowOutlineNormallyActive
    {
      public:
      enum type { Inactive, Active, COUNT };
      static const char* const enumToString[];
    };
    class EnumVaryColorIcon
    {
      public:
      enum type { No, Opaque, MostOpaqueHover, Transparent, MostTransparentHover, Light, LightestHover, Dark, DarkestHover, MoreTitleBar, MostTitleBarHover, LessTitleBar, LeastTitleBarHover, COUNT };
    };
    class EnumVaryColorIconActive
    {
      public:
      enum type { Inactive, Active, COUNT };
      static const char* const enumToString[];
    };
    class EnumVaryColorBackground
    {
      public:
      enum type { No, Opaque, MostOpaqueHover, Transparent, MostTransparentHover, Light, LightestHover, Dark, DarkestHover, MoreTitleBar, MostTitleBarHover, LessTitleBar, LeastTitleBarHover, COUNT };
    };
    class EnumVaryColorBackgroundActive
    {
      public:
      enum type { Inactive, Active, COUNT };
      static const char* const enumToString[];
    };
    class EnumVaryColorOutline
    {
      public:
      enum type { No, Opaque, MostOpaqueHover, Transparent, MostTransparentHover, Light, LightestHover, Dark, DarkestHover, MoreTitleBar, MostTitleBarHover, LessTitleBar, LeastTitleBarHover, COUNT };
    };
    class EnumVaryColorOutlineActive
    {
      public:
      enum type { Inactive, Active, COUNT };
      static const char* const enumToString[];
    };
    class EnumButtonStateChecked
    {
      public:
      enum type { Hover, Press, COUNT };
    };
    class EnumButtonStateCheckedActive
    {
      public:
      enum type { Inactive, Active, COUNT };
      static const char* const enumToString[];
    };
    class EnumShowCloseIconOnPressActive
    {
      public:
      enum type { Inactive, Active, COUNT };
      static const char* const enumToString[];
    };
    class EnumShowCloseBackgroundOnPressActive
    {
      public:
      enum type { Inactive, Active, COUNT };
      static const char* const enumToString[];
    };
    class EnumShowCloseOutlineOnPressActive
    {
      public:
      enum type { Inactive, Active, COUNT };
      static const char* const enumToString[];
    };
    class EnumShowCloseIconOnHoverActive
    {
      public:
      enum type { Inactive, Active, COUNT };
      static const char* const enumToString[];
    };
    class EnumShowCloseBackgroundOnHoverActive
    {
      public:
      enum type { Inactive, Active, COUNT };
      static const char* const enumToString[];
    };
    class EnumShowCloseOutlineOnHoverActive
    {
      public:
      enum type { Inactive, Active, COUNT };
      static const char* const enumToString[];
    };
    class EnumShowCloseIconNormallyActive
    {
      public:
      enum type { Inactive, Active, COUNT };
      static const char* const enumToString[];
    };
    class EnumShowCloseBackgroundNormallyActive
    {
      public:
      enum type { Inactive, Active, COUNT };
      static const char* const enumToString[];
    };
    class EnumShowCloseOutlineNormallyActive
    {
      public:
      enum type { Inactive, Active, COUNT };
      static const char* const enumToString[];
    };
    class EnumVaryColorCloseIcon
    {
      public:
      enum type { No, Opaque, MostOpaqueHover, Transparent, MostTransparentHover, Light, LightestHover, Dark, DarkestHover, MoreTitleBar, MostTitleBarHover, LessTitleBar, LeastTitleBarHover, COUNT };
    };
    class EnumVaryColorCloseIconActive
    {
      public:
      enum type { Inactive, Active, COUNT };
      static const char* const enumToString[];
    };
    class EnumVaryColorCloseBackground
    {
      public:
      enum type { No, Opaque, MostOpaqueHover, Transparent, MostTransparentHover, Light, LightestHover, Dark, DarkestHover, MoreTitleBar, MostTitleBarHover, LessTitleBar, LeastTitleBarHover, COUNT };
    };
    class EnumVaryColorCloseBackgroundActive
    {
      public:
      enum type { Inactive, Active, COUNT };
      static const char* const enumToString[];
    };
    class EnumVaryColorCloseOutline
    {
      public:
      enum type { No, Opaque, MostOpaqueHover, Transparent, MostTransparentHover, Light, LightestHover, Dark, DarkestHover, MoreTitleBar, MostTitleBarHover, LessTitleBar, LeastTitleBarHover, COUNT };
    };
    class EnumVaryColorCloseOutlineActive
    {
      public:
      enum type { Inactive, Active, COUNT };
      static const char* const enumToString[];
    };
    class EnumLockCloseButtonBehaviourActive
    {
      public:
      enum type { Inactive, Active, COUNT };
      static const char* const enumToString[];
    };
    class EnumTitleAlignment
    {
      public:
      enum type { AlignLeft, AlignCenter, AlignCenterFullWidth, AlignRight, COUNT };
    };
    class EnumWindowOutlineStyle
    {
      public:
      enum type { WindowOutlineNone, WindowOutlineShadowColor, WindowOutlineContrast, WindowOutlineAccentColor, WindowOutlineAccentWithContrast, WindowOutlineCustomColor, WindowOutlineCustomWithContrast, COUNT };
    };
    class EnumWindowOutlineStyleActive
    {
      public:
      enum type { Inactive, Active, COUNT };
      static const char* const enumToString[];
    };
    class EnumWindowOutlineCustomColorActive
    {
      public:
      enum type { Inactive, Active, COUNT };
      static const char* const enumToString[];
    };
    class EnumWindowOutlineContrastOpacityActive
    {
      public:
      enum type { Inactive, Active, COUNT };
      static const char* const enumToString[];
    };
    class EnumWindowOutlineAccentColorOpacityActive
    {
      public:
      enum type { Inactive, Active, COUNT };
      static const char* const enumToString[];
    };
    class EnumWindowOutlineAccentWithContrastOpacityActive
    {
      public:
      enum type { Inactive, Active, COUNT };
      static const char* const enumToString[];
    };
    class EnumWindowOutlineCustomColorOpacityActive
    {
      public:
      enum type { Inactive, Active, COUNT };
      static const char* const enumToString[];
    };
    class EnumWindowOutlineCustomWithContrastOpacityActive
    {
      public:
      enum type { Inactive, Active, COUNT };
      static const char* const enumToString[];
    };
    class EnumShadowSize
    {
      public:
      enum type { ShadowNone, ShadowSmall, ShadowMedium, ShadowLarge, ShadowVeryLarge, COUNT };
    };
    class EnumHideTitleBar
    {
      public:
      enum type { Never, Always, Maximized, AnyMaximization, KeptBehind, AnyMaximizationOrKeptBehind, COUNT };
    };
    class EnumExceptionWindowPropertyType
    {
      public:
      enum type { ExceptionWindowClassName, ExceptionWindowTitle, COUNT };
    };
    class EnumBorderSize
    {
      public:
      enum type { None, NoSides, Tiny, Normal, Large, VeryLarge, Huge, VeryHuge, Oversized, COUNT };
    };

    InternalSettings( );
    ~InternalSettings() override;

    /**
      Set LookAndFeelSet
    */
    void setLookAndFeelSet( const QString & v )
    {
      if (!isLookAndFeelSetImmutable())
        mLookAndFeelSet = v;
    }

    /**
      Get LookAndFeelSet
    */
    QString lookAndFeelSet() const
    {
      return mLookAndFeelSet;
    }

    /**
      Is LookAndFeelSet Immutable
    */
    bool isLookAndFeelSetImmutable() const
    {
      return isImmutable( QStringLiteral( "LookAndFeelSet" ) );
    }

    /**
      Set RefreshedConfig
    */
    void setRefreshedConfig( const QString & v )
    {
      if (!isRefreshedConfigImmutable())
        mRefreshedConfig = v;
    }

    /**
      Get RefreshedConfig
    */
    QString refreshedConfig() const
    {
      return mRefreshedConfig;
    }

    /**
      Is RefreshedConfig Immutable
    */
    bool isRefreshedConfigImmutable() const
    {
      return isImmutable( QStringLiteral( "RefreshedConfig" ) );
    }

    /**
      Set ButtonIconStyle
    */
    void setButtonIconStyle( int v )
    {
      if (!isButtonIconStyleImmutable())
        mButtonIconStyle = v;
    }

    /**
      Get ButtonIconStyle
    */
    int buttonIconStyle() const
    {
      return mButtonIconStyle;
    }

    /**
      Is ButtonIconStyle Immutable
    */
    bool isButtonIconStyleImmutable() const
    {
      return isImmutable( QStringLiteral( "ButtonIconStyle" ) );
    }

    /**
      Set IconSize
    */
    void setIconSize( int v )
    {
      if (!isIconSizeImmutable())
        mIconSize = v;
    }

    /**
      Get IconSize
    */
    int iconSize() const
    {
      return mIconSize;
    }

    /**
      Is IconSize Immutable
    */
    bool isIconSizeImmutable() const
    {
      return isImmutable( QStringLiteral( "IconSize" ) );
    }

    /**
      Set SystemIconSize
    */
    void setSystemIconSize( int v )
    {
      if (!isSystemIconSizeImmutable())
        mSystemIconSize = v;
    }

    /**
      Get SystemIconSize
    */
    int systemIconSize() const
    {
      return mSystemIconSize;
    }

    /**
      Is SystemIconSize Immutable
    */
    bool isSystemIconSizeImmutable() const
    {
      return isImmutable( QStringLiteral( "SystemIconSize" ) );
    }

    /**
      Set ForceColorizeSystemIcons
    */
    void setForceColorizeSystemIcons( bool v )
    {
      if (!isForceColorizeSystemIconsImmutable())
        mForceColorizeSystemIcons = v;
    }

    /**
      Get ForceColorizeSystemIcons
    */
    bool forceColorizeSystemIcons() const
    {
      return mForceColorizeSystemIcons;
    }

    /**
      Is ForceColorizeSystemIcons Immutable
    */
    bool isForceColorizeSystemIconsImmutable() const
    {
      return isImmutable( QStringLiteral( "ForceColorizeSystemIcons" ) );
    }

    /**
      Set BoldButtonIcons
    */
    void setBoldButtonIcons( int v )
    {
      if (!isBoldButtonIconsImmutable())
        mBoldButtonIcons = v;
    }

    /**
      Get BoldButtonIcons
    */
    int boldButtonIcons() const
    {
      return mBoldButtonIcons;
    }

    /**
      Is BoldButtonIcons Immutable
    */
    bool isBoldButtonIconsImmutable() const
    {
      return isImmutable( QStringLiteral( "BoldButtonIcons" ) );
    }

    /**
      Set ButtonShape
    */
    void setButtonShape( int v )
    {
      if (!isButtonShapeImmutable())
        mButtonShape = v;
    }

    /**
      Get ButtonShape
    */
    int buttonShape() const
    {
      return mButtonShape;
    }

    /**
      Is ButtonShape Immutable
    */
    bool isButtonShapeImmutable() const
    {
      return isImmutable( QStringLiteral( "ButtonShape" ) );
    }

    /**
      Set MatchTitleBarToApplicationColor
    */
    void setMatchTitleBarToApplicationColor( bool v )
    {
      if (!isMatchTitleBarToApplicationColorImmutable())
        mMatchTitleBarToApplicationColor = v;
    }

    /**
      Get MatchTitleBarToApplicationColor
    */
    bool matchTitleBarToApplicationColor() const
    {
      return mMatchTitleBarToApplicationColor;
    }

    /**
      Is MatchTitleBarToApplicationColor Immutable
    */
    bool isMatchTitleBarToApplicationColorImmutable() const
    {
      return isImmutable( QStringLiteral( "MatchTitleBarToApplicationColor" ) );
    }

    /**
      Set DrawBackgroundGradient
    */
    void setDrawBackgroundGradient( bool v )
    {
      if (!isDrawBackgroundGradientImmutable())
        mDrawBackgroundGradient = v;
    }

    /**
      Get DrawBackgroundGradient
    */
    bool drawBackgroundGradient() const
    {
      return mDrawBackgroundGradient;
    }

    /**
      Is DrawBackgroundGradient Immutable
    */
    bool isDrawBackgroundGradientImmutable() const
    {
      return isImmutable( QStringLiteral( "DrawBackgroundGradient" ) );
    }

    /**
      Set DrawTitleBarSeparator
    */
    void setDrawTitleBarSeparator( bool v )
    {
      if (!isDrawTitleBarSeparatorImmutable())
        mDrawTitleBarSeparator = v;
    }

    /**
      Get DrawTitleBarSeparator
    */
    bool drawTitleBarSeparator() const
    {
      return mDrawTitleBarSeparator;
    }

    /**
      Is DrawTitleBarSeparator Immutable
    */
    bool isDrawTitleBarSeparatorImmutable() const
    {
      return isImmutable( QStringLiteral( "DrawTitleBarSeparator" ) );
    }

    /**
      Set BoldTitle
    */
    void setBoldTitle( bool v )
    {
      if (!isBoldTitleImmutable())
        mBoldTitle = v;
    }

    /**
      Get BoldTitle
    */
    bool boldTitle() const
    {
      return mBoldTitle;
    }

    /**
      Is BoldTitle Immutable
    */
    bool isBoldTitleImmutable() const
    {
      return isImmutable( QStringLiteral( "BoldTitle" ) );
    }

    /**
      Set UnderlineTitle
    */
    void setUnderlineTitle( bool v )
    {
      if (!isUnderlineTitleImmutable())
        mUnderlineTitle = v;
    }

    /**
      Get UnderlineTitle
    */
    bool underlineTitle() const
    {
      return mUnderlineTitle;
    }

    /**
      Is UnderlineTitle Immutable
    */
    bool isUnderlineTitleImmutable() const
    {
      return isImmutable( QStringLiteral( "UnderlineTitle" ) );
    }

    /**
      Set WindowCornerRadius
    */
    void setWindowCornerRadius( double v )
    {
      if (v < 0)
      {
        qDebug() << "setWindowCornerRadius: value " << v << " is less than the minimum value of 0";
        v = 0;
      }

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

      if (!isWindowCornerRadiusImmutable())
        mWindowCornerRadius = v;
    }

    /**
      Get WindowCornerRadius
    */
    double windowCornerRadius() const
    {
      return mWindowCornerRadius;
    }

    /**
      Is WindowCornerRadius Immutable
    */
    bool isWindowCornerRadiusImmutable() const
    {
      return isImmutable( QStringLiteral( "WindowCornerRadius" ) );
    }

    /**
      Set RoundAllCornersWhenNoBorders
    */
    void setRoundAllCornersWhenNoBorders( bool v )
    {
      if (!isRoundAllCornersWhenNoBordersImmutable())
        mRoundAllCornersWhenNoBorders = v;
    }

    /**
      Get RoundAllCornersWhenNoBorders
    */
    bool roundAllCornersWhenNoBorders() const
    {
      return mRoundAllCornersWhenNoBorders;
    }

    /**
      Is RoundAllCornersWhenNoBorders Immutable
    */
    bool isRoundAllCornersWhenNoBordersImmutable() const
    {
      return isImmutable( QStringLiteral( "RoundAllCornersWhenNoBorders" ) );
    }

    /**
      Set UseTitleBarColorForAllBorders
    */
    void setUseTitleBarColorForAllBorders( bool v )
    {
      if (!isUseTitleBarColorForAllBordersImmutable())
        mUseTitleBarColorForAllBorders = v;
    }

    /**
      Get UseTitleBarColorForAllBorders
    */
    bool useTitleBarColorForAllBorders() const
    {
      return mUseTitleBarColorForAllBorders;
    }

    /**
      Is UseTitleBarColorForAllBorders Immutable
    */
    bool isUseTitleBarColorForAllBordersImmutable() const
    {
      return isImmutable( QStringLiteral( "UseTitleBarColorForAllBorders" ) );
    }

    /**
      Set DrawBorderOnMaximizedWindows
    */
    void setDrawBorderOnMaximizedWindows( bool v )
    {
      if (!isDrawBorderOnMaximizedWindowsImmutable())
        mDrawBorderOnMaximizedWindows = v;
    }

    /**
      Get DrawBorderOnMaximizedWindows
    */
    bool drawBorderOnMaximizedWindows() const
    {
      return mDrawBorderOnMaximizedWindows;
    }

    /**
      Is DrawBorderOnMaximizedWindows Immutable
    */
    bool isDrawBorderOnMaximizedWindowsImmutable() const
    {
      return isImmutable( QStringLiteral( "DrawBorderOnMaximizedWindows" ) );
    }

    /**
      Set ColorizeWindowOutlineWithButton
    */
    void setColorizeWindowOutlineWithButton( bool v )
    {
      if (!isColorizeWindowOutlineWithButtonImmutable())
        mColorizeWindowOutlineWithButton = v;
    }

    /**
      Get ColorizeWindowOutlineWithButton
    */
    bool colorizeWindowOutlineWithButton() const
    {
      return mColorizeWindowOutlineWithButton;
    }

    /**
      Is ColorizeWindowOutlineWithButton Immutable
    */
    bool isColorizeWindowOutlineWithButtonImmutable() const
    {
      return isImmutable( QStringLiteral( "ColorizeWindowOutlineWithButton" ) );
    }

    /**
      Set AnimationsEnabled
    */
    void setAnimationsEnabled( bool v )
    {
      if (!isAnimationsEnabledImmutable())
        mAnimationsEnabled = v;
    }

    /**
      Get AnimationsEnabled
    */
    bool animationsEnabled() const
    {
      return mAnimationsEnabled;
    }

    /**
      Is AnimationsEnabled Immutable
    */
    bool isAnimationsEnabledImmutable() const
    {
      return isImmutable( QStringLiteral( "AnimationsEnabled" ) );
    }

    /**
      Set AnimationsSpeedRelativeSystem
    */
    void setAnimationsSpeedRelativeSystem( int v )
    {
      if (v < -10)
      {
        qDebug() << "setAnimationsSpeedRelativeSystem: value " << v << " is less than the minimum value of -10";
        v = -10;
      }

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

      if (!isAnimationsSpeedRelativeSystemImmutable())
        mAnimationsSpeedRelativeSystem = v;
    }

    /**
      Get AnimationsSpeedRelativeSystem
    */
    int animationsSpeedRelativeSystem() const
    {
      return mAnimationsSpeedRelativeSystem;
    }

    /**
      Is AnimationsSpeedRelativeSystem Immutable
    */
    bool isAnimationsSpeedRelativeSystemImmutable() const
    {
      return isImmutable( QStringLiteral( "AnimationsSpeedRelativeSystem" ) );
    }

    /**
      Set KlassyIconThemeInherits
    */
    void setKlassyIconThemeInherits( const QString & v )
    {
      if (!isKlassyIconThemeInheritsImmutable())
        mKlassyIconThemeInherits = v;
    }

    /**
      Get KlassyIconThemeInherits
    */
    QString klassyIconThemeInherits() const
    {
      return mKlassyIconThemeInherits;
    }

    /**
      Is KlassyIconThemeInherits Immutable
    */
    bool isKlassyIconThemeInheritsImmutable() const
    {
      return isImmutable( QStringLiteral( "KlassyIconThemeInherits" ) );
    }

    /**
      Set KlassyDarkIconThemeInherits
    */
    void setKlassyDarkIconThemeInherits( const QString & v )
    {
      if (!isKlassyDarkIconThemeInheritsImmutable())
        mKlassyDarkIconThemeInherits = v;
    }

    /**
      Get KlassyDarkIconThemeInherits
    */
    QString klassyDarkIconThemeInherits() const
    {
      return mKlassyDarkIconThemeInherits;
    }

    /**
      Is KlassyDarkIconThemeInherits Immutable
    */
    bool isKlassyDarkIconThemeInheritsImmutable() const
    {
      return isImmutable( QStringLiteral( "KlassyDarkIconThemeInherits" ) );
    }

    /**
      Set ScaleBackgroundPercent
    */
    void setScaleBackgroundPercent( int v )
    {
      if (v < 100)
      {
        qDebug() << "setScaleBackgroundPercent: value " << v << " is less than the minimum value of 100";
        v = 100;
      }

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

      if (!isScaleBackgroundPercentImmutable())
        mScaleBackgroundPercent = v;
    }

    /**
      Get ScaleBackgroundPercent
    */
    int scaleBackgroundPercent() const
    {
      return mScaleBackgroundPercent;
    }

    /**
      Is ScaleBackgroundPercent Immutable
    */
    bool isScaleBackgroundPercentImmutable() const
    {
      return isImmutable( QStringLiteral( "ScaleBackgroundPercent" ) );
    }

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

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

      if (!isButtonSpacingLeftImmutable())
        mButtonSpacingLeft = v;
    }

    /**
      Get ButtonSpacingLeft
    */
    int buttonSpacingLeft() const
    {
      return mButtonSpacingLeft;
    }

    /**
      Is ButtonSpacingLeft Immutable
    */
    bool isButtonSpacingLeftImmutable() const
    {
      return isImmutable( QStringLiteral( "ButtonSpacingLeft" ) );
    }

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

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

      if (!isButtonSpacingRightImmutable())
        mButtonSpacingRight = v;
    }

    /**
      Get ButtonSpacingRight
    */
    int buttonSpacingRight() const
    {
      return mButtonSpacingRight;
    }

    /**
      Is ButtonSpacingRight Immutable
    */
    bool isButtonSpacingRightImmutable() const
    {
      return isImmutable( QStringLiteral( "ButtonSpacingRight" ) );
    }

    /**
      Set LockButtonSpacingLeftRight
    */
    void setLockButtonSpacingLeftRight( bool v )
    {
      if (!isLockButtonSpacingLeftRightImmutable())
        mLockButtonSpacingLeftRight = v;
    }

    /**
      Get LockButtonSpacingLeftRight
    */
    bool lockButtonSpacingLeftRight() const
    {
      return mLockButtonSpacingLeftRight;
    }

    /**
      Is LockButtonSpacingLeftRight Immutable
    */
    bool isLockButtonSpacingLeftRightImmutable() const
    {
      return isImmutable( QStringLiteral( "LockButtonSpacingLeftRight" ) );
    }

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

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

      if (!isFullHeightButtonWidthMarginLeftImmutable())
        mFullHeightButtonWidthMarginLeft = v;
    }

    /**
      Get FullHeightButtonWidthMarginLeft
    */
    int fullHeightButtonWidthMarginLeft() const
    {
      return mFullHeightButtonWidthMarginLeft;
    }

    /**
      Is FullHeightButtonWidthMarginLeft Immutable
    */
    bool isFullHeightButtonWidthMarginLeftImmutable() const
    {
      return isImmutable( QStringLiteral( "FullHeightButtonWidthMarginLeft" ) );
    }

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

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

      if (!isFullHeightButtonWidthMarginRightImmutable())
        mFullHeightButtonWidthMarginRight = v;
    }

    /**
      Get FullHeightButtonWidthMarginRight
    */
    int fullHeightButtonWidthMarginRight() const
    {
      return mFullHeightButtonWidthMarginRight;
    }

    /**
      Is FullHeightButtonWidthMarginRight Immutable
    */
    bool isFullHeightButtonWidthMarginRightImmutable() const
    {
      return isImmutable( QStringLiteral( "FullHeightButtonWidthMarginRight" ) );
    }

    /**
      Set CloseFullHeightButtonWidthMarginRelative
    */
    void setCloseFullHeightButtonWidthMarginRelative( int v )
    {
      if (v < 25)
      {
        qDebug() << "setCloseFullHeightButtonWidthMarginRelative: value " << v << " is less than the minimum value of 25";
        v = 25;
      }

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

      if (!isCloseFullHeightButtonWidthMarginRelativeImmutable())
        mCloseFullHeightButtonWidthMarginRelative = v;
    }

    /**
      Get CloseFullHeightButtonWidthMarginRelative
    */
    int closeFullHeightButtonWidthMarginRelative() const
    {
      return mCloseFullHeightButtonWidthMarginRelative;
    }

    /**
      Is CloseFullHeightButtonWidthMarginRelative Immutable
    */
    bool isCloseFullHeightButtonWidthMarginRelativeImmutable() const
    {
      return isImmutable( QStringLiteral( "CloseFullHeightButtonWidthMarginRelative" ) );
    }

    /**
      Set LockFullHeightButtonWidthMargins
    */
    void setLockFullHeightButtonWidthMargins( bool v )
    {
      if (!isLockFullHeightButtonWidthMarginsImmutable())
        mLockFullHeightButtonWidthMargins = v;
    }

    /**
      Get LockFullHeightButtonWidthMargins
    */
    bool lockFullHeightButtonWidthMargins() const
    {
      return mLockFullHeightButtonWidthMargins;
    }

    /**
      Is LockFullHeightButtonWidthMargins Immutable
    */
    bool isLockFullHeightButtonWidthMarginsImmutable() const
    {
      return isImmutable( QStringLiteral( "LockFullHeightButtonWidthMargins" ) );
    }

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

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

      if (!isFullHeightButtonSpacingLeftImmutable())
        mFullHeightButtonSpacingLeft = v;
    }

    /**
      Get FullHeightButtonSpacingLeft
    */
    int fullHeightButtonSpacingLeft() const
    {
      return mFullHeightButtonSpacingLeft;
    }

    /**
      Is FullHeightButtonSpacingLeft Immutable
    */
    bool isFullHeightButtonSpacingLeftImmutable() const
    {
      return isImmutable( QStringLiteral( "FullHeightButtonSpacingLeft" ) );
    }

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

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

      if (!isFullHeightButtonSpacingRightImmutable())
        mFullHeightButtonSpacingRight = v;
    }

    /**
      Get FullHeightButtonSpacingRight
    */
    int fullHeightButtonSpacingRight() const
    {
      return mFullHeightButtonSpacingRight;
    }

    /**
      Is FullHeightButtonSpacingRight Immutable
    */
    bool isFullHeightButtonSpacingRightImmutable() const
    {
      return isImmutable( QStringLiteral( "FullHeightButtonSpacingRight" ) );
    }

    /**
      Set LockFullHeightButtonSpacingLeftRight
    */
    void setLockFullHeightButtonSpacingLeftRight( bool v )
    {
      if (!isLockFullHeightButtonSpacingLeftRightImmutable())
        mLockFullHeightButtonSpacingLeftRight = v;
    }

    /**
      Get LockFullHeightButtonSpacingLeftRight
    */
    bool lockFullHeightButtonSpacingLeftRight() const
    {
      return mLockFullHeightButtonSpacingLeftRight;
    }

    /**
      Is LockFullHeightButtonSpacingLeftRight Immutable
    */
    bool isLockFullHeightButtonSpacingLeftRightImmutable() const
    {
      return isImmutable( QStringLiteral( "LockFullHeightButtonSpacingLeftRight" ) );
    }

    /**
      Set ButtonCornerRadius
    */
    void setButtonCornerRadius( int v )
    {
      if (!isButtonCornerRadiusImmutable())
        mButtonCornerRadius = v;
    }

    /**
      Get ButtonCornerRadius
    */
    int buttonCornerRadius() const
    {
      return mButtonCornerRadius;
    }

    /**
      Is ButtonCornerRadius Immutable
    */
    bool isButtonCornerRadiusImmutable() const
    {
      return isImmutable( QStringLiteral( "ButtonCornerRadius" ) );
    }

    /**
      Set ButtonCustomCornerRadius
    */
    void setButtonCustomCornerRadius( double v )
    {
      if (v < 0)
      {
        qDebug() << "setButtonCustomCornerRadius: value " << v << " is less than the minimum value of 0";
        v = 0;
      }

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

      if (!isButtonCustomCornerRadiusImmutable())
        mButtonCustomCornerRadius = v;
    }

    /**
      Get ButtonCustomCornerRadius
    */
    double buttonCustomCornerRadius() const
    {
      return mButtonCustomCornerRadius;
    }

    /**
      Is ButtonCustomCornerRadius Immutable
    */
    bool isButtonCustomCornerRadiusImmutable() const
    {
      return isImmutable( QStringLiteral( "ButtonCustomCornerRadius" ) );
    }

    /**
      Set IntegratedRoundedRectangleBottomPadding
    */
    void setIntegratedRoundedRectangleBottomPadding( double v )
    {
      if (v < 0)
      {
        qDebug() << "setIntegratedRoundedRectangleBottomPadding: value " << v << " is less than the minimum value of 0";
        v = 0;
      }

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

      if (!isIntegratedRoundedRectangleBottomPaddingImmutable())
        mIntegratedRoundedRectangleBottomPadding = v;
    }

    /**
      Get IntegratedRoundedRectangleBottomPadding
    */
    double integratedRoundedRectangleBottomPadding() const
    {
      return mIntegratedRoundedRectangleBottomPadding;
    }

    /**
      Is IntegratedRoundedRectangleBottomPadding Immutable
    */
    bool isIntegratedRoundedRectangleBottomPaddingImmutable() const
    {
      return isImmutable( QStringLiteral( "IntegratedRoundedRectangleBottomPadding" ) );
    }

    /**
      Set SpacerButtonWidthRelative
    */
    void setSpacerButtonWidthRelative( int v )
    {
      if (v < 1)
      {
        qDebug() << "setSpacerButtonWidthRelative: value " << v << " is less than the minimum value of 1";
        v = 1;
      }

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

      if (!isSpacerButtonWidthRelativeImmutable())
        mSpacerButtonWidthRelative = v;
    }

    /**
      Get SpacerButtonWidthRelative
    */
    int spacerButtonWidthRelative() const
    {
      return mSpacerButtonWidthRelative;
    }

    /**
      Is SpacerButtonWidthRelative Immutable
    */
    bool isSpacerButtonWidthRelativeImmutable() const
    {
      return isImmutable( QStringLiteral( "SpacerButtonWidthRelative" ) );
    }

    /**
      Set ScaleTouchMode
    */
    void setScaleTouchMode( int v )
    {
      if (v < 100)
      {
        qDebug() << "setScaleTouchMode: value " << v << " is less than the minimum value of 100";
        v = 100;
      }

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

      if (!isScaleTouchModeImmutable())
        mScaleTouchMode = v;
    }

    /**
      Get ScaleTouchMode
    */
    int scaleTouchMode() const
    {
      return mScaleTouchMode;
    }

    /**
      Is ScaleTouchMode Immutable
    */
    bool isScaleTouchModeImmutable() const
    {
      return isImmutable( QStringLiteral( "ScaleTouchMode" ) );
    }

    /**
      Set LockButtonColorsActiveInactive
    */
    void setLockButtonColorsActiveInactive( bool v )
    {
      if (!isLockButtonColorsActiveInactiveImmutable())
        mLockButtonColorsActiveInactive = v;
    }

    /**
      Get LockButtonColorsActiveInactive
    */
    bool lockButtonColorsActiveInactive() const
    {
      return mLockButtonColorsActiveInactive;
    }

    /**
      Is LockButtonColorsActiveInactive Immutable
    */
    bool isLockButtonColorsActiveInactiveImmutable() const
    {
      return isImmutable( QStringLiteral( "LockButtonColorsActiveInactive" ) );
    }

    /**
      Set ButtonColorsInactiveSameHoverPress
    */
    void setButtonColorsInactiveSameHoverPress( bool v )
    {
      if (!isButtonColorsInactiveSameHoverPressImmutable())
        mButtonColorsInactiveSameHoverPress = v;
    }

    /**
      Get ButtonColorsInactiveSameHoverPress
    */
    bool buttonColorsInactiveSameHoverPress() const
    {
      return mButtonColorsInactiveSameHoverPress;
    }

    /**
      Is ButtonColorsInactiveSameHoverPress Immutable
    */
    bool isButtonColorsInactiveSameHoverPressImmutable() const
    {
      return isImmutable( QStringLiteral( "ButtonColorsInactiveSameHoverPress" ) );
    }

    /**
      Set ButtonIconColors$(ButtonIconColorsActive)
    */
    void setButtonIconColors( int i, int v )
    {
      if (!isButtonIconColorsImmutable( i ))
        mButtonIconColors[i] = v;
    }

    /**
      Get ButtonIconColors$(ButtonIconColorsActive)
    */
    int buttonIconColors( int i ) const
    {
      return mButtonIconColors[i];
    }

    /**
      Is ButtonIconColors$(ButtonIconColorsActive) Immutable
    */
    bool isButtonIconColorsImmutable( int i ) const
    {
      return isImmutable( QStringLiteral( "ButtonIconColors%1" ).arg( QLatin1String( EnumButtonIconColorsActive::enumToString[i] ) ) );
    }

    /**
      Set CloseButtonIconColor$(CloseButtonIconColorActive)
    */
    void setCloseButtonIconColor( int i, int v )
    {
      if (!isCloseButtonIconColorImmutable( i ))
        mCloseButtonIconColor[i] = v;
    }

    /**
      Get CloseButtonIconColor$(CloseButtonIconColorActive)
    */
    int closeButtonIconColor( int i ) const
    {
      return mCloseButtonIconColor[i];
    }

    /**
      Is CloseButtonIconColor$(CloseButtonIconColorActive) Immutable
    */
    bool isCloseButtonIconColorImmutable( int i ) const
    {
      return isImmutable( QStringLiteral( "CloseButtonIconColor%1" ).arg( QLatin1String( EnumCloseButtonIconColorActive::enumToString[i] ) ) );
    }

    /**
      Set OnPoorIconContrast$(OnPoorIconContrastActive)
    */
    void setOnPoorIconContrast( int i, int v )
    {
      if (!isOnPoorIconContrastImmutable( i ))
        mOnPoorIconContrast[i] = v;
    }

    /**
      Get OnPoorIconContrast$(OnPoorIconContrastActive)
    */
    int onPoorIconContrast( int i ) const
    {
      return mOnPoorIconContrast[i];
    }

    /**
      Is OnPoorIconContrast$(OnPoorIconContrastActive) Immutable
    */
    bool isOnPoorIconContrastImmutable( int i ) const
    {
      return isImmutable( QStringLiteral( "OnPoorIconContrast%1" ).arg( QLatin1String( EnumOnPoorIconContrastActive::enumToString[i] ) ) );
    }

    /**
      Set PoorIconContrastThreshold$(PoorIconContrastThresholdActive)
    */
    void setPoorIconContrastThreshold( int i, double v )
    {
      if (v < 1.0)
      {
        qDebug() << "setPoorIconContrastThreshold: value " << v << " is less than the minimum value of 1.0";
        v = 1.0;
      }

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

      if (!isPoorIconContrastThresholdImmutable( i ))
        mPoorIconContrastThreshold[i] = v;
    }

    /**
      Get PoorIconContrastThreshold$(PoorIconContrastThresholdActive)
    */
    double poorIconContrastThreshold( int i ) const
    {
      return mPoorIconContrastThreshold[i];
    }

    /**
      Is PoorIconContrastThreshold$(PoorIconContrastThresholdActive) Immutable
    */
    bool isPoorIconContrastThresholdImmutable( int i ) const
    {
      return isImmutable( QStringLiteral( "PoorIconContrastThreshold%1" ).arg( QLatin1String( EnumPoorIconContrastThresholdActive::enumToString[i] ) ) );
    }

    /**
      Set ButtonBackgroundColors$(ButtonBackgroundColorsActive)
    */
    void setButtonBackgroundColors( int i, int v )
    {
      if (!isButtonBackgroundColorsImmutable( i ))
        mButtonBackgroundColors[i] = v;
    }

    /**
      Get ButtonBackgroundColors$(ButtonBackgroundColorsActive)
    */
    int buttonBackgroundColors( int i ) const
    {
      return mButtonBackgroundColors[i];
    }

    /**
      Is ButtonBackgroundColors$(ButtonBackgroundColorsActive) Immutable
    */
    bool isButtonBackgroundColorsImmutable( int i ) const
    {
      return isImmutable( QStringLiteral( "ButtonBackgroundColors%1" ).arg( QLatin1String( EnumButtonBackgroundColorsActive::enumToString[i] ) ) );
    }

    /**
      Set NegativeCloseBackgroundHoverPress$(NegativeCloseBackgroundHoverPressActive)
    */
    void setNegativeCloseBackgroundHoverPress( int i, bool v )
    {
      if (!isNegativeCloseBackgroundHoverPressImmutable( i ))
        mNegativeCloseBackgroundHoverPress[i] = v;
    }

    /**
      Get NegativeCloseBackgroundHoverPress$(NegativeCloseBackgroundHoverPressActive)
    */
    bool negativeCloseBackgroundHoverPress( int i ) const
    {
      return mNegativeCloseBackgroundHoverPress[i];
    }

    /**
      Is NegativeCloseBackgroundHoverPress$(NegativeCloseBackgroundHoverPressActive) Immutable
    */
    bool isNegativeCloseBackgroundHoverPressImmutable( int i ) const
    {
      return isImmutable( QStringLiteral( "NegativeCloseBackgroundHoverPress%1" ).arg( QLatin1String( EnumNegativeCloseBackgroundHoverPressActive::enumToString[i] ) ) );
    }

    /**
      Set UseHoverAccent$(UseHoverAccentActive)
    */
    void setUseHoverAccent( int i, bool v )
    {
      if (!isUseHoverAccentImmutable( i ))
        mUseHoverAccent[i] = v;
    }

    /**
      Get UseHoverAccent$(UseHoverAccentActive)
    */
    bool useHoverAccent( int i ) const
    {
      return mUseHoverAccent[i];
    }

    /**
      Is UseHoverAccent$(UseHoverAccentActive) Immutable
    */
    bool isUseHoverAccentImmutable( int i ) const
    {
      return isImmutable( QStringLiteral( "UseHoverAccent%1" ).arg( QLatin1String( EnumUseHoverAccentActive::enumToString[i] ) ) );
    }

    /**
      Set AdjustBackgroundColorOnPoorContrast$(AdjustBackgroundColorOnPoorContrastActive)
    */
    void setAdjustBackgroundColorOnPoorContrast( int i, bool v )
    {
      if (!isAdjustBackgroundColorOnPoorContrastImmutable( i ))
        mAdjustBackgroundColorOnPoorContrast[i] = v;
    }

    /**
      Get AdjustBackgroundColorOnPoorContrast$(AdjustBackgroundColorOnPoorContrastActive)
    */
    bool adjustBackgroundColorOnPoorContrast( int i ) const
    {
      return mAdjustBackgroundColorOnPoorContrast[i];
    }

    /**
      Is AdjustBackgroundColorOnPoorContrast$(AdjustBackgroundColorOnPoorContrastActive) Immutable
    */
    bool isAdjustBackgroundColorOnPoorContrastImmutable( int i ) const
    {
      return isImmutable( QStringLiteral( "AdjustBackgroundColorOnPoorContrast%1" ).arg( QLatin1String( EnumAdjustBackgroundColorOnPoorContrastActive::enumToString[i] ) ) );
    }

    /**
      Set PoorBackgroundContrastThreshold$(PoorBackgroundContrastThresholdActive)
    */
    void setPoorBackgroundContrastThreshold( int i, double v )
    {
      if (v < 1.0)
      {
        qDebug() << "setPoorBackgroundContrastThreshold: value " << v << " is less than the minimum value of 1.0";
        v = 1.0;
      }

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

      if (!isPoorBackgroundContrastThresholdImmutable( i ))
        mPoorBackgroundContrastThreshold[i] = v;
    }

    /**
      Get PoorBackgroundContrastThreshold$(PoorBackgroundContrastThresholdActive)
    */
    double poorBackgroundContrastThreshold( int i ) const
    {
      return mPoorBackgroundContrastThreshold[i];
    }

    /**
      Is PoorBackgroundContrastThreshold$(PoorBackgroundContrastThresholdActive) Immutable
    */
    bool isPoorBackgroundContrastThresholdImmutable( int i ) const
    {
      return isImmutable( QStringLiteral( "PoorBackgroundContrastThreshold%1" ).arg( QLatin1String( EnumPoorBackgroundContrastThresholdActive::enumToString[i] ) ) );
    }

    /**
      Set ButtonIconOpacity$(ButtonIconOpacityActive)
    */
    void setButtonIconOpacity( int i, int v )
    {
      if (v < 0)
      {
        qDebug() << "setButtonIconOpacity: value " << v << " is less than the minimum value of 0";
        v = 0;
      }

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

      if (!isButtonIconOpacityImmutable( i ))
        mButtonIconOpacity[i] = v;
    }

    /**
      Get ButtonIconOpacity$(ButtonIconOpacityActive)
    */
    int buttonIconOpacity( int i ) const
    {
      return mButtonIconOpacity[i];
    }

    /**
      Is ButtonIconOpacity$(ButtonIconOpacityActive) Immutable
    */
    bool isButtonIconOpacityImmutable( int i ) const
    {
      return isImmutable( QStringLiteral( "ButtonIconOpacity%1" ).arg( QLatin1String( EnumButtonIconOpacityActive::enumToString[i] ) ) );
    }

    /**
      Set ButtonBackgroundOpacity$(ButtonBackgroundOpacityActive)
    */
    void setButtonBackgroundOpacity( int i, int v )
    {
      if (v < 0)
      {
        qDebug() << "setButtonBackgroundOpacity: value " << v << " is less than the minimum value of 0";
        v = 0;
      }

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

      if (!isButtonBackgroundOpacityImmutable( i ))
        mButtonBackgroundOpacity[i] = v;
    }

    /**
      Get ButtonBackgroundOpacity$(ButtonBackgroundOpacityActive)
    */
    int buttonBackgroundOpacity( int i ) const
    {
      return mButtonBackgroundOpacity[i];
    }

    /**
      Is ButtonBackgroundOpacity$(ButtonBackgroundOpacityActive) Immutable
    */
    bool isButtonBackgroundOpacityImmutable( int i ) const
    {
      return isImmutable( QStringLiteral( "ButtonBackgroundOpacity%1" ).arg( QLatin1String( EnumButtonBackgroundOpacityActive::enumToString[i] ) ) );
    }

    /**
      Set ButtonOverrideColorsActive$(ButtonOverrideColorsActiveButtonType)
    */
    void setButtonOverrideColorsActive( int i, const QString & v )
    {
      if (!isButtonOverrideColorsActiveImmutable( i ))
        mButtonOverrideColorsActive[i] = v;
    }

    /**
      Get ButtonOverrideColorsActive$(ButtonOverrideColorsActiveButtonType)
    */
    QString buttonOverrideColorsActive( int i ) const
    {
      return mButtonOverrideColorsActive[i];
    }

    /**
      Is ButtonOverrideColorsActive$(ButtonOverrideColorsActiveButtonType) Immutable
    */
    bool isButtonOverrideColorsActiveImmutable( int i ) const
    {
      return isImmutable( QStringLiteral( "ButtonOverrideColorsActive%1" ).arg( QLatin1String( EnumButtonOverrideColorsActiveButtonType::enumToString[i] ) ) );
    }

    /**
      Set ButtonOverrideColorsInactive$(ButtonOverrideColorsInactiveButtonType)
    */
    void setButtonOverrideColorsInactive( int i, const QString & v )
    {
      if (!isButtonOverrideColorsInactiveImmutable( i ))
        mButtonOverrideColorsInactive[i] = v;
    }

    /**
      Get ButtonOverrideColorsInactive$(ButtonOverrideColorsInactiveButtonType)
    */
    QString buttonOverrideColorsInactive( int i ) const
    {
      return mButtonOverrideColorsInactive[i];
    }

    /**
      Is ButtonOverrideColorsInactive$(ButtonOverrideColorsInactiveButtonType) Immutable
    */
    bool isButtonOverrideColorsInactiveImmutable( int i ) const
    {
      return isImmutable( QStringLiteral( "ButtonOverrideColorsInactive%1" ).arg( QLatin1String( EnumButtonOverrideColorsInactiveButtonType::enumToString[i] ) ) );
    }

    /**
      Set ButtonOverrideColorsLockStates$(ButtonOverrideColorsLockStatesActive)
    */
    void setButtonOverrideColorsLockStates( int i, const QString & v )
    {
      if (!isButtonOverrideColorsLockStatesImmutable( i ))
        mButtonOverrideColorsLockStates[i] = v;
    }

    /**
      Get ButtonOverrideColorsLockStates$(ButtonOverrideColorsLockStatesActive)
    */
    QString buttonOverrideColorsLockStates( int i ) const
    {
      return mButtonOverrideColorsLockStates[i];
    }

    /**
      Is ButtonOverrideColorsLockStates$(ButtonOverrideColorsLockStatesActive) Immutable
    */
    bool isButtonOverrideColorsLockStatesImmutable( int i ) const
    {
      return isImmutable( QStringLiteral( "ButtonOverrideColorsLockStates%1" ).arg( QLatin1String( EnumButtonOverrideColorsLockStatesActive::enumToString[i] ) ) );
    }

    /**
      Set ShowIconOnPress$(ShowIconOnPressActive)
    */
    void setShowIconOnPress( int i, bool v )
    {
      if (!isShowIconOnPressImmutable( i ))
        mShowIconOnPress[i] = v;
    }

    /**
      Get ShowIconOnPress$(ShowIconOnPressActive)
    */
    bool showIconOnPress( int i ) const
    {
      return mShowIconOnPress[i];
    }

    /**
      Is ShowIconOnPress$(ShowIconOnPressActive) Immutable
    */
    bool isShowIconOnPressImmutable( int i ) const
    {
      return isImmutable( QStringLiteral( "ShowIconOnPress%1" ).arg( QLatin1String( EnumShowIconOnPressActive::enumToString[i] ) ) );
    }

    /**
      Set ShowBackgroundOnPress$(ShowBackgroundOnPressActive)
    */
    void setShowBackgroundOnPress( int i, bool v )
    {
      if (!isShowBackgroundOnPressImmutable( i ))
        mShowBackgroundOnPress[i] = v;
    }

    /**
      Get ShowBackgroundOnPress$(ShowBackgroundOnPressActive)
    */
    bool showBackgroundOnPress( int i ) const
    {
      return mShowBackgroundOnPress[i];
    }

    /**
      Is ShowBackgroundOnPress$(ShowBackgroundOnPressActive) Immutable
    */
    bool isShowBackgroundOnPressImmutable( int i ) const
    {
      return isImmutable( QStringLiteral( "ShowBackgroundOnPress%1" ).arg( QLatin1String( EnumShowBackgroundOnPressActive::enumToString[i] ) ) );
    }

    /**
      Set ShowOutlineOnPress$(ShowOutlineOnPressActive)
    */
    void setShowOutlineOnPress( int i, bool v )
    {
      if (!isShowOutlineOnPressImmutable( i ))
        mShowOutlineOnPress[i] = v;
    }

    /**
      Get ShowOutlineOnPress$(ShowOutlineOnPressActive)
    */
    bool showOutlineOnPress( int i ) const
    {
      return mShowOutlineOnPress[i];
    }

    /**
      Is ShowOutlineOnPress$(ShowOutlineOnPressActive) Immutable
    */
    bool isShowOutlineOnPressImmutable( int i ) const
    {
      return isImmutable( QStringLiteral( "ShowOutlineOnPress%1" ).arg( QLatin1String( EnumShowOutlineOnPressActive::enumToString[i] ) ) );
    }

    /**
      Set ShowIconOnHover$(ShowIconOnHoverActive)
    */
    void setShowIconOnHover( int i, bool v )
    {
      if (!isShowIconOnHoverImmutable( i ))
        mShowIconOnHover[i] = v;
    }

    /**
      Get ShowIconOnHover$(ShowIconOnHoverActive)
    */
    bool showIconOnHover( int i ) const
    {
      return mShowIconOnHover[i];
    }

    /**
      Is ShowIconOnHover$(ShowIconOnHoverActive) Immutable
    */
    bool isShowIconOnHoverImmutable( int i ) const
    {
      return isImmutable( QStringLiteral( "ShowIconOnHover%1" ).arg( QLatin1String( EnumShowIconOnHoverActive::enumToString[i] ) ) );
    }

    /**
      Set ShowBackgroundOnHover$(ShowBackgroundOnHoverActive)
    */
    void setShowBackgroundOnHover( int i, bool v )
    {
      if (!isShowBackgroundOnHoverImmutable( i ))
        mShowBackgroundOnHover[i] = v;
    }

    /**
      Get ShowBackgroundOnHover$(ShowBackgroundOnHoverActive)
    */
    bool showBackgroundOnHover( int i ) const
    {
      return mShowBackgroundOnHover[i];
    }

    /**
      Is ShowBackgroundOnHover$(ShowBackgroundOnHoverActive) Immutable
    */
    bool isShowBackgroundOnHoverImmutable( int i ) const
    {
      return isImmutable( QStringLiteral( "ShowBackgroundOnHover%1" ).arg( QLatin1String( EnumShowBackgroundOnHoverActive::enumToString[i] ) ) );
    }

    /**
      Set ShowOutlineOnHover$(ShowOutlineOnHoverActive)
    */
    void setShowOutlineOnHover( int i, bool v )
    {
      if (!isShowOutlineOnHoverImmutable( i ))
        mShowOutlineOnHover[i] = v;
    }

    /**
      Get ShowOutlineOnHover$(ShowOutlineOnHoverActive)
    */
    bool showOutlineOnHover( int i ) const
    {
      return mShowOutlineOnHover[i];
    }

    /**
      Is ShowOutlineOnHover$(ShowOutlineOnHoverActive) Immutable
    */
    bool isShowOutlineOnHoverImmutable( int i ) const
    {
      return isImmutable( QStringLiteral( "ShowOutlineOnHover%1" ).arg( QLatin1String( EnumShowOutlineOnHoverActive::enumToString[i] ) ) );
    }

    /**
      Set ShowIconNormally$(ShowIconNormallyActive)
    */
    void setShowIconNormally( int i, bool v )
    {
      if (!isShowIconNormallyImmutable( i ))
        mShowIconNormally[i] = v;
    }

    /**
      Get ShowIconNormally$(ShowIconNormallyActive)
    */
    bool showIconNormally( int i ) const
    {
      return mShowIconNormally[i];
    }

    /**
      Is ShowIconNormally$(ShowIconNormallyActive) Immutable
    */
    bool isShowIconNormallyImmutable( int i ) const
    {
      return isImmutable( QStringLiteral( "ShowIconNormally%1" ).arg( QLatin1String( EnumShowIconNormallyActive::enumToString[i] ) ) );
    }

    /**
      Set ShowBackgroundNormally$(ShowBackgroundNormallyActive)
    */
    void setShowBackgroundNormally( int i, bool v )
    {
      if (!isShowBackgroundNormallyImmutable( i ))
        mShowBackgroundNormally[i] = v;
    }

    /**
      Get ShowBackgroundNormally$(ShowBackgroundNormallyActive)
    */
    bool showBackgroundNormally( int i ) const
    {
      return mShowBackgroundNormally[i];
    }

    /**
      Is ShowBackgroundNormally$(ShowBackgroundNormallyActive) Immutable
    */
    bool isShowBackgroundNormallyImmutable( int i ) const
    {
      return isImmutable( QStringLiteral( "ShowBackgroundNormally%1" ).arg( QLatin1String( EnumShowBackgroundNormallyActive::enumToString[i] ) ) );
    }

    /**
      Set ShowOutlineNormally$(ShowOutlineNormallyActive)
    */
    void setShowOutlineNormally( int i, bool v )
    {
      if (!isShowOutlineNormallyImmutable( i ))
        mShowOutlineNormally[i] = v;
    }

    /**
      Get ShowOutlineNormally$(ShowOutlineNormallyActive)
    */
    bool showOutlineNormally( int i ) const
    {
      return mShowOutlineNormally[i];
    }

    /**
      Is ShowOutlineNormally$(ShowOutlineNormallyActive) Immutable
    */
    bool isShowOutlineNormallyImmutable( int i ) const
    {
      return isImmutable( QStringLiteral( "ShowOutlineNormally%1" ).arg( QLatin1String( EnumShowOutlineNormallyActive::enumToString[i] ) ) );
    }

    /**
      Set VaryColorIcon$(VaryColorIconActive)
    */
    void setVaryColorIcon( int i, int v )
    {
      if (!isVaryColorIconImmutable( i ))
        mVaryColorIcon[i] = v;
    }

    /**
      Get VaryColorIcon$(VaryColorIconActive)
    */
    int varyColorIcon( int i ) const
    {
      return mVaryColorIcon[i];
    }

    /**
      Is VaryColorIcon$(VaryColorIconActive) Immutable
    */
    bool isVaryColorIconImmutable( int i ) const
    {
      return isImmutable( QStringLiteral( "VaryColorIcon%1" ).arg( QLatin1String( EnumVaryColorIconActive::enumToString[i] ) ) );
    }

    /**
      Set VaryColorBackground$(VaryColorBackgroundActive)
    */
    void setVaryColorBackground( int i, int v )
    {
      if (!isVaryColorBackgroundImmutable( i ))
        mVaryColorBackground[i] = v;
    }

    /**
      Get VaryColorBackground$(VaryColorBackgroundActive)
    */
    int varyColorBackground( int i ) const
    {
      return mVaryColorBackground[i];
    }

    /**
      Is VaryColorBackground$(VaryColorBackgroundActive) Immutable
    */
    bool isVaryColorBackgroundImmutable( int i ) const
    {
      return isImmutable( QStringLiteral( "VaryColorBackground%1" ).arg( QLatin1String( EnumVaryColorBackgroundActive::enumToString[i] ) ) );
    }

    /**
      Set VaryColorOutline$(VaryColorOutlineActive)
    */
    void setVaryColorOutline( int i, int v )
    {
      if (!isVaryColorOutlineImmutable( i ))
        mVaryColorOutline[i] = v;
    }

    /**
      Get VaryColorOutline$(VaryColorOutlineActive)
    */
    int varyColorOutline( int i ) const
    {
      return mVaryColorOutline[i];
    }

    /**
      Is VaryColorOutline$(VaryColorOutlineActive) Immutable
    */
    bool isVaryColorOutlineImmutable( int i ) const
    {
      return isImmutable( QStringLiteral( "VaryColorOutline%1" ).arg( QLatin1String( EnumVaryColorOutlineActive::enumToString[i] ) ) );
    }

    /**
      Set ButtonStateChecked$(ButtonStateCheckedActive)
    */
    void setButtonStateChecked( int i, int v )
    {
      if (!isButtonStateCheckedImmutable( i ))
        mButtonStateChecked[i] = v;
    }

    /**
      Get ButtonStateChecked$(ButtonStateCheckedActive)
    */
    int buttonStateChecked( int i ) const
    {
      return mButtonStateChecked[i];
    }

    /**
      Is ButtonStateChecked$(ButtonStateCheckedActive) Immutable
    */
    bool isButtonStateCheckedImmutable( int i ) const
    {
      return isImmutable( QStringLiteral( "ButtonStateChecked%1" ).arg( QLatin1String( EnumButtonStateCheckedActive::enumToString[i] ) ) );
    }

    /**
      Set ShowCloseIconOnPress$(ShowCloseIconOnPressActive)
    */
    void setShowCloseIconOnPress( int i, bool v )
    {
      if (!isShowCloseIconOnPressImmutable( i ))
        mShowCloseIconOnPress[i] = v;
    }

    /**
      Get ShowCloseIconOnPress$(ShowCloseIconOnPressActive)
    */
    bool showCloseIconOnPress( int i ) const
    {
      return mShowCloseIconOnPress[i];
    }

    /**
      Is ShowCloseIconOnPress$(ShowCloseIconOnPressActive) Immutable
    */
    bool isShowCloseIconOnPressImmutable( int i ) const
    {
      return isImmutable( QStringLiteral( "ShowCloseIconOnPress%1" ).arg( QLatin1String( EnumShowCloseIconOnPressActive::enumToString[i] ) ) );
    }

    /**
      Set ShowCloseBackgroundOnPress$(ShowCloseBackgroundOnPressActive)
    */
    void setShowCloseBackgroundOnPress( int i, bool v )
    {
      if (!isShowCloseBackgroundOnPressImmutable( i ))
        mShowCloseBackgroundOnPress[i] = v;
    }

    /**
      Get ShowCloseBackgroundOnPress$(ShowCloseBackgroundOnPressActive)
    */
    bool showCloseBackgroundOnPress( int i ) const
    {
      return mShowCloseBackgroundOnPress[i];
    }

    /**
      Is ShowCloseBackgroundOnPress$(ShowCloseBackgroundOnPressActive) Immutable
    */
    bool isShowCloseBackgroundOnPressImmutable( int i ) const
    {
      return isImmutable( QStringLiteral( "ShowCloseBackgroundOnPress%1" ).arg( QLatin1String( EnumShowCloseBackgroundOnPressActive::enumToString[i] ) ) );
    }

    /**
      Set ShowCloseOutlineOnPress$(ShowCloseOutlineOnPressActive)
    */
    void setShowCloseOutlineOnPress( int i, bool v )
    {
      if (!isShowCloseOutlineOnPressImmutable( i ))
        mShowCloseOutlineOnPress[i] = v;
    }

    /**
      Get ShowCloseOutlineOnPress$(ShowCloseOutlineOnPressActive)
    */
    bool showCloseOutlineOnPress( int i ) const
    {
      return mShowCloseOutlineOnPress[i];
    }

    /**
      Is ShowCloseOutlineOnPress$(ShowCloseOutlineOnPressActive) Immutable
    */
    bool isShowCloseOutlineOnPressImmutable( int i ) const
    {
      return isImmutable( QStringLiteral( "ShowCloseOutlineOnPress%1" ).arg( QLatin1String( EnumShowCloseOutlineOnPressActive::enumToString[i] ) ) );
    }

    /**
      Set ShowCloseIconOnHover$(ShowCloseIconOnHoverActive)
    */
    void setShowCloseIconOnHover( int i, bool v )
    {
      if (!isShowCloseIconOnHoverImmutable( i ))
        mShowCloseIconOnHover[i] = v;
    }

    /**
      Get ShowCloseIconOnHover$(ShowCloseIconOnHoverActive)
    */
    bool showCloseIconOnHover( int i ) const
    {
      return mShowCloseIconOnHover[i];
    }

    /**
      Is ShowCloseIconOnHover$(ShowCloseIconOnHoverActive) Immutable
    */
    bool isShowCloseIconOnHoverImmutable( int i ) const
    {
      return isImmutable( QStringLiteral( "ShowCloseIconOnHover%1" ).arg( QLatin1String( EnumShowCloseIconOnHoverActive::enumToString[i] ) ) );
    }

    /**
      Set ShowCloseBackgroundOnHover$(ShowCloseBackgroundOnHoverActive)
    */
    void setShowCloseBackgroundOnHover( int i, bool v )
    {
      if (!isShowCloseBackgroundOnHoverImmutable( i ))
        mShowCloseBackgroundOnHover[i] = v;
    }

    /**
      Get ShowCloseBackgroundOnHover$(ShowCloseBackgroundOnHoverActive)
    */
    bool showCloseBackgroundOnHover( int i ) const
    {
      return mShowCloseBackgroundOnHover[i];
    }

    /**
      Is ShowCloseBackgroundOnHover$(ShowCloseBackgroundOnHoverActive) Immutable
    */
    bool isShowCloseBackgroundOnHoverImmutable( int i ) const
    {
      return isImmutable( QStringLiteral( "ShowCloseBackgroundOnHover%1" ).arg( QLatin1String( EnumShowCloseBackgroundOnHoverActive::enumToString[i] ) ) );
    }

    /**
      Set ShowCloseOutlineOnHover$(ShowCloseOutlineOnHoverActive)
    */
    void setShowCloseOutlineOnHover( int i, bool v )
    {
      if (!isShowCloseOutlineOnHoverImmutable( i ))
        mShowCloseOutlineOnHover[i] = v;
    }

    /**
      Get ShowCloseOutlineOnHover$(ShowCloseOutlineOnHoverActive)
    */
    bool showCloseOutlineOnHover( int i ) const
    {
      return mShowCloseOutlineOnHover[i];
    }

    /**
      Is ShowCloseOutlineOnHover$(ShowCloseOutlineOnHoverActive) Immutable
    */
    bool isShowCloseOutlineOnHoverImmutable( int i ) const
    {
      return isImmutable( QStringLiteral( "ShowCloseOutlineOnHover%1" ).arg( QLatin1String( EnumShowCloseOutlineOnHoverActive::enumToString[i] ) ) );
    }

    /**
      Set ShowCloseIconNormally$(ShowCloseIconNormallyActive)
    */
    void setShowCloseIconNormally( int i, bool v )
    {
      if (!isShowCloseIconNormallyImmutable( i ))
        mShowCloseIconNormally[i] = v;
    }

    /**
      Get ShowCloseIconNormally$(ShowCloseIconNormallyActive)
    */
    bool showCloseIconNormally( int i ) const
    {
      return mShowCloseIconNormally[i];
    }

    /**
      Is ShowCloseIconNormally$(ShowCloseIconNormallyActive) Immutable
    */
    bool isShowCloseIconNormallyImmutable( int i ) const
    {
      return isImmutable( QStringLiteral( "ShowCloseIconNormally%1" ).arg( QLatin1String( EnumShowCloseIconNormallyActive::enumToString[i] ) ) );
    }

    /**
      Set ShowCloseBackgroundNormally$(ShowCloseBackgroundNormallyActive)
    */
    void setShowCloseBackgroundNormally( int i, bool v )
    {
      if (!isShowCloseBackgroundNormallyImmutable( i ))
        mShowCloseBackgroundNormally[i] = v;
    }

    /**
      Get ShowCloseBackgroundNormally$(ShowCloseBackgroundNormallyActive)
    */
    bool showCloseBackgroundNormally( int i ) const
    {
      return mShowCloseBackgroundNormally[i];
    }

    /**
      Is ShowCloseBackgroundNormally$(ShowCloseBackgroundNormallyActive) Immutable
    */
    bool isShowCloseBackgroundNormallyImmutable( int i ) const
    {
      return isImmutable( QStringLiteral( "ShowCloseBackgroundNormally%1" ).arg( QLatin1String( EnumShowCloseBackgroundNormallyActive::enumToString[i] ) ) );
    }

    /**
      Set ShowCloseOutlineNormally$(ShowCloseOutlineNormallyActive)
    */
    void setShowCloseOutlineNormally( int i, bool v )
    {
      if (!isShowCloseOutlineNormallyImmutable( i ))
        mShowCloseOutlineNormally[i] = v;
    }

    /**
      Get ShowCloseOutlineNormally$(ShowCloseOutlineNormallyActive)
    */
    bool showCloseOutlineNormally( int i ) const
    {
      return mShowCloseOutlineNormally[i];
    }

    /**
      Is ShowCloseOutlineNormally$(ShowCloseOutlineNormallyActive) Immutable
    */
    bool isShowCloseOutlineNormallyImmutable( int i ) const
    {
      return isImmutable( QStringLiteral( "ShowCloseOutlineNormally%1" ).arg( QLatin1String( EnumShowCloseOutlineNormallyActive::enumToString[i] ) ) );
    }

    /**
      Set VaryColorCloseIcon$(VaryColorCloseIconActive)
    */
    void setVaryColorCloseIcon( int i, int v )
    {
      if (!isVaryColorCloseIconImmutable( i ))
        mVaryColorCloseIcon[i] = v;
    }

    /**
      Get VaryColorCloseIcon$(VaryColorCloseIconActive)
    */
    int varyColorCloseIcon( int i ) const
    {
      return mVaryColorCloseIcon[i];
    }

    /**
      Is VaryColorCloseIcon$(VaryColorCloseIconActive) Immutable
    */
    bool isVaryColorCloseIconImmutable( int i ) const
    {
      return isImmutable( QStringLiteral( "VaryColorCloseIcon%1" ).arg( QLatin1String( EnumVaryColorCloseIconActive::enumToString[i] ) ) );
    }

    /**
      Set VaryColorCloseBackground$(VaryColorCloseBackgroundActive)
    */
    void setVaryColorCloseBackground( int i, int v )
    {
      if (!isVaryColorCloseBackgroundImmutable( i ))
        mVaryColorCloseBackground[i] = v;
    }

    /**
      Get VaryColorCloseBackground$(VaryColorCloseBackgroundActive)
    */
    int varyColorCloseBackground( int i ) const
    {
      return mVaryColorCloseBackground[i];
    }

    /**
      Is VaryColorCloseBackground$(VaryColorCloseBackgroundActive) Immutable
    */
    bool isVaryColorCloseBackgroundImmutable( int i ) const
    {
      return isImmutable( QStringLiteral( "VaryColorCloseBackground%1" ).arg( QLatin1String( EnumVaryColorCloseBackgroundActive::enumToString[i] ) ) );
    }

    /**
      Set VaryColorCloseOutline$(VaryColorCloseOutlineActive)
    */
    void setVaryColorCloseOutline( int i, int v )
    {
      if (!isVaryColorCloseOutlineImmutable( i ))
        mVaryColorCloseOutline[i] = v;
    }

    /**
      Get VaryColorCloseOutline$(VaryColorCloseOutlineActive)
    */
    int varyColorCloseOutline( int i ) const
    {
      return mVaryColorCloseOutline[i];
    }

    /**
      Is VaryColorCloseOutline$(VaryColorCloseOutlineActive) Immutable
    */
    bool isVaryColorCloseOutlineImmutable( int i ) const
    {
      return isImmutable( QStringLiteral( "VaryColorCloseOutline%1" ).arg( QLatin1String( EnumVaryColorCloseOutlineActive::enumToString[i] ) ) );
    }

    /**
      Set LockCloseButtonBehaviour$(LockCloseButtonBehaviourActive)
    */
    void setLockCloseButtonBehaviour( int i, bool v )
    {
      if (!isLockCloseButtonBehaviourImmutable( i ))
        mLockCloseButtonBehaviour[i] = v;
    }

    /**
      Get LockCloseButtonBehaviour$(LockCloseButtonBehaviourActive)
    */
    bool lockCloseButtonBehaviour( int i ) const
    {
      return mLockCloseButtonBehaviour[i];
    }

    /**
      Is LockCloseButtonBehaviour$(LockCloseButtonBehaviourActive) Immutable
    */
    bool isLockCloseButtonBehaviourImmutable( int i ) const
    {
      return isImmutable( QStringLiteral( "LockCloseButtonBehaviour%1" ).arg( QLatin1String( EnumLockCloseButtonBehaviourActive::enumToString[i] ) ) );
    }

    /**
      Set LockButtonBehaviourActiveInactive
    */
    void setLockButtonBehaviourActiveInactive( bool v )
    {
      if (!isLockButtonBehaviourActiveInactiveImmutable())
        mLockButtonBehaviourActiveInactive = v;
    }

    /**
      Get LockButtonBehaviourActiveInactive
    */
    bool lockButtonBehaviourActiveInactive() const
    {
      return mLockButtonBehaviourActiveInactive;
    }

    /**
      Is LockButtonBehaviourActiveInactive Immutable
    */
    bool isLockButtonBehaviourActiveInactiveImmutable() const
    {
      return isImmutable( QStringLiteral( "LockButtonBehaviourActiveInactive" ) );
    }

    /**
      Set UnisonHovering
    */
    void setUnisonHovering( bool v )
    {
      if (!isUnisonHoveringImmutable())
        mUnisonHovering = v;
    }

    /**
      Get UnisonHovering
    */
    bool unisonHovering() const
    {
      return mUnisonHovering;
    }

    /**
      Is UnisonHovering Immutable
    */
    bool isUnisonHoveringImmutable() const
    {
      return isImmutable( QStringLiteral( "UnisonHovering" ) );
    }

    /**
      Set TitleBarTopMargin
    */
    void setTitleBarTopMargin( double v )
    {
      if (v < 0)
      {
        qDebug() << "setTitleBarTopMargin: value " << v << " is less than the minimum value of 0";
        v = 0;
      }

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

      if (!isTitleBarTopMarginImmutable())
        mTitleBarTopMargin = v;
    }

    /**
      Get TitleBarTopMargin
    */
    double titleBarTopMargin() const
    {
      return mTitleBarTopMargin;
    }

    /**
      Is TitleBarTopMargin Immutable
    */
    bool isTitleBarTopMarginImmutable() const
    {
      return isImmutable( QStringLiteral( "TitleBarTopMargin" ) );
    }

    /**
      Set TitleBarBottomMargin
    */
    void setTitleBarBottomMargin( double v )
    {
      if (v < 0)
      {
        qDebug() << "setTitleBarBottomMargin: value " << v << " is less than the minimum value of 0";
        v = 0;
      }

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

      if (!isTitleBarBottomMarginImmutable())
        mTitleBarBottomMargin = v;
    }

    /**
      Get TitleBarBottomMargin
    */
    double titleBarBottomMargin() const
    {
      return mTitleBarBottomMargin;
    }

    /**
      Is TitleBarBottomMargin Immutable
    */
    bool isTitleBarBottomMarginImmutable() const
    {
      return isImmutable( QStringLiteral( "TitleBarBottomMargin" ) );
    }

    /**
      Set LockTitleBarTopBottomMargins
    */
    void setLockTitleBarTopBottomMargins( bool v )
    {
      if (!isLockTitleBarTopBottomMarginsImmutable())
        mLockTitleBarTopBottomMargins = v;
    }

    /**
      Get LockTitleBarTopBottomMargins
    */
    bool lockTitleBarTopBottomMargins() const
    {
      return mLockTitleBarTopBottomMargins;
    }

    /**
      Is LockTitleBarTopBottomMargins Immutable
    */
    bool isLockTitleBarTopBottomMarginsImmutable() const
    {
      return isImmutable( QStringLiteral( "LockTitleBarTopBottomMargins" ) );
    }

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

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

      if (!isTitleBarLeftMarginImmutable())
        mTitleBarLeftMargin = v;
    }

    /**
      Get TitleBarLeftMargin
    */
    int titleBarLeftMargin() const
    {
      return mTitleBarLeftMargin;
    }

    /**
      Is TitleBarLeftMargin Immutable
    */
    bool isTitleBarLeftMarginImmutable() const
    {
      return isImmutable( QStringLiteral( "TitleBarLeftMargin" ) );
    }

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

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

      if (!isTitleBarRightMarginImmutable())
        mTitleBarRightMargin = v;
    }

    /**
      Get TitleBarRightMargin
    */
    int titleBarRightMargin() const
    {
      return mTitleBarRightMargin;
    }

    /**
      Is TitleBarRightMargin Immutable
    */
    bool isTitleBarRightMarginImmutable() const
    {
      return isImmutable( QStringLiteral( "TitleBarRightMargin" ) );
    }

    /**
      Set LockTitleBarLeftRightMargins
    */
    void setLockTitleBarLeftRightMargins( bool v )
    {
      if (!isLockTitleBarLeftRightMarginsImmutable())
        mLockTitleBarLeftRightMargins = v;
    }

    /**
      Get LockTitleBarLeftRightMargins
    */
    bool lockTitleBarLeftRightMargins() const
    {
      return mLockTitleBarLeftRightMargins;
    }

    /**
      Is LockTitleBarLeftRightMargins Immutable
    */
    bool isLockTitleBarLeftRightMarginsImmutable() const
    {
      return isImmutable( QStringLiteral( "LockTitleBarLeftRightMargins" ) );
    }

    /**
      Set TitleAlignment
    */
    void setTitleAlignment( int v )
    {
      if (!isTitleAlignmentImmutable())
        mTitleAlignment = v;
    }

    /**
      Get TitleAlignment
    */
    int titleAlignment() const
    {
      return mTitleAlignment;
    }

    /**
      Is TitleAlignment Immutable
    */
    bool isTitleAlignmentImmutable() const
    {
      return isImmutable( QStringLiteral( "TitleAlignment" ) );
    }

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

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

      if (!isTitleSidePaddingImmutable())
        mTitleSidePadding = v;
    }

    /**
      Get TitleSidePadding
    */
    int titleSidePadding() const
    {
      return mTitleSidePadding;
    }

    /**
      Is TitleSidePadding Immutable
    */
    bool isTitleSidePaddingImmutable() const
    {
      return isImmutable( QStringLiteral( "TitleSidePadding" ) );
    }

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

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

      if (!isPercentMaximizedTopBottomMarginsImmutable())
        mPercentMaximizedTopBottomMargins = v;
    }

    /**
      Get PercentMaximizedTopBottomMargins
    */
    int percentMaximizedTopBottomMargins() const
    {
      return mPercentMaximizedTopBottomMargins;
    }

    /**
      Is PercentMaximizedTopBottomMargins Immutable
    */
    bool isPercentMaximizedTopBottomMarginsImmutable() const
    {
      return isImmutable( QStringLiteral( "PercentMaximizedTopBottomMargins" ) );
    }

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

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

      if (!isActiveTitleBarOpacityImmutable())
        mActiveTitleBarOpacity = v;
    }

    /**
      Get ActiveTitleBarOpacity
    */
    int activeTitleBarOpacity() const
    {
      return mActiveTitleBarOpacity;
    }

    /**
      Is ActiveTitleBarOpacity Immutable
    */
    bool isActiveTitleBarOpacityImmutable() const
    {
      return isImmutable( QStringLiteral( "ActiveTitleBarOpacity" ) );
    }

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

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

      if (!isInactiveTitleBarOpacityImmutable())
        mInactiveTitleBarOpacity = v;
    }

    /**
      Get InactiveTitleBarOpacity
    */
    int inactiveTitleBarOpacity() const
    {
      return mInactiveTitleBarOpacity;
    }

    /**
      Is InactiveTitleBarOpacity Immutable
    */
    bool isInactiveTitleBarOpacityImmutable() const
    {
      return isImmutable( QStringLiteral( "InactiveTitleBarOpacity" ) );
    }

    /**
      Set OpaqueMaximizedTitleBars
    */
    void setOpaqueMaximizedTitleBars( bool v )
    {
      if (!isOpaqueMaximizedTitleBarsImmutable())
        mOpaqueMaximizedTitleBars = v;
    }

    /**
      Get OpaqueMaximizedTitleBars
    */
    bool opaqueMaximizedTitleBars() const
    {
      return mOpaqueMaximizedTitleBars;
    }

    /**
      Is OpaqueMaximizedTitleBars Immutable
    */
    bool isOpaqueMaximizedTitleBarsImmutable() const
    {
      return isImmutable( QStringLiteral( "OpaqueMaximizedTitleBars" ) );
    }

    /**
      Set BlurTransparentTitleBars
    */
    void setBlurTransparentTitleBars( bool v )
    {
      if (!isBlurTransparentTitleBarsImmutable())
        mBlurTransparentTitleBars = v;
    }

    /**
      Get BlurTransparentTitleBars
    */
    bool blurTransparentTitleBars() const
    {
      return mBlurTransparentTitleBars;
    }

    /**
      Is BlurTransparentTitleBars Immutable
    */
    bool isBlurTransparentTitleBarsImmutable() const
    {
      return isImmutable( QStringLiteral( "BlurTransparentTitleBars" ) );
    }

    /**
      Set ApplyOpacityToHeader
    */
    void setApplyOpacityToHeader( bool v )
    {
      if (!isApplyOpacityToHeaderImmutable())
        mApplyOpacityToHeader = v;
    }

    /**
      Get ApplyOpacityToHeader
    */
    bool applyOpacityToHeader() const
    {
      return mApplyOpacityToHeader;
    }

    /**
      Is ApplyOpacityToHeader Immutable
    */
    bool isApplyOpacityToHeaderImmutable() const
    {
      return isImmutable( QStringLiteral( "ApplyOpacityToHeader" ) );
    }

    /**
      Set OverrideActiveTitleBarOpacity
    */
    void setOverrideActiveTitleBarOpacity( bool v )
    {
      if (!isOverrideActiveTitleBarOpacityImmutable())
        mOverrideActiveTitleBarOpacity = v;
    }

    /**
      Get OverrideActiveTitleBarOpacity
    */
    bool overrideActiveTitleBarOpacity() const
    {
      return mOverrideActiveTitleBarOpacity;
    }

    /**
      Is OverrideActiveTitleBarOpacity Immutable
    */
    bool isOverrideActiveTitleBarOpacityImmutable() const
    {
      return isImmutable( QStringLiteral( "OverrideActiveTitleBarOpacity" ) );
    }

    /**
      Set OverrideInactiveTitleBarOpacity
    */
    void setOverrideInactiveTitleBarOpacity( bool v )
    {
      if (!isOverrideInactiveTitleBarOpacityImmutable())
        mOverrideInactiveTitleBarOpacity = v;
    }

    /**
      Get OverrideInactiveTitleBarOpacity
    */
    bool overrideInactiveTitleBarOpacity() const
    {
      return mOverrideInactiveTitleBarOpacity;
    }

    /**
      Is OverrideInactiveTitleBarOpacity Immutable
    */
    bool isOverrideInactiveTitleBarOpacityImmutable() const
    {
      return isImmutable( QStringLiteral( "OverrideInactiveTitleBarOpacity" ) );
    }

    /**
      Set WindowOutlineThickness
    */
    void setWindowOutlineThickness( double v )
    {
      if (v < 0.5)
      {
        qDebug() << "setWindowOutlineThickness: value " << v << " is less than the minimum value of 0.5";
        v = 0.5;
      }

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

      if (!isWindowOutlineThicknessImmutable())
        mWindowOutlineThickness = v;
    }

    /**
      Get WindowOutlineThickness
    */
    double windowOutlineThickness() const
    {
      return mWindowOutlineThickness;
    }

    /**
      Is WindowOutlineThickness Immutable
    */
    bool isWindowOutlineThicknessImmutable() const
    {
      return isImmutable( QStringLiteral( "WindowOutlineThickness" ) );
    }

    /**
      Set WindowOutlineSnapToWholePixel
    */
    void setWindowOutlineSnapToWholePixel( bool v )
    {
      if (!isWindowOutlineSnapToWholePixelImmutable())
        mWindowOutlineSnapToWholePixel = v;
    }

    /**
      Get WindowOutlineSnapToWholePixel
    */
    bool windowOutlineSnapToWholePixel() const
    {
      return mWindowOutlineSnapToWholePixel;
    }

    /**
      Is WindowOutlineSnapToWholePixel Immutable
    */
    bool isWindowOutlineSnapToWholePixelImmutable() const
    {
      return isImmutable( QStringLiteral( "WindowOutlineSnapToWholePixel" ) );
    }

    /**
      Set WindowOutlineOverlap
    */
    void setWindowOutlineOverlap( bool v )
    {
      if (!isWindowOutlineOverlapImmutable())
        mWindowOutlineOverlap = v;
    }

    /**
      Get WindowOutlineOverlap
    */
    bool windowOutlineOverlap() const
    {
      return mWindowOutlineOverlap;
    }

    /**
      Is WindowOutlineOverlap Immutable
    */
    bool isWindowOutlineOverlapImmutable() const
    {
      return isImmutable( QStringLiteral( "WindowOutlineOverlap" ) );
    }

    /**
      Set WindowOutlineStyle$(WindowOutlineStyleActive)
    */
    void setWindowOutlineStyle( int i, int v )
    {
      if (!isWindowOutlineStyleImmutable( i ))
        mWindowOutlineStyle[i] = v;
    }

    /**
      Get WindowOutlineStyle$(WindowOutlineStyleActive)
    */
    int windowOutlineStyle( int i ) const
    {
      return mWindowOutlineStyle[i];
    }

    /**
      Is WindowOutlineStyle$(WindowOutlineStyleActive) Immutable
    */
    bool isWindowOutlineStyleImmutable( int i ) const
    {
      return isImmutable( QStringLiteral( "WindowOutlineStyle%1" ).arg( QLatin1String( EnumWindowOutlineStyleActive::enumToString[i] ) ) );
    }

    /**
      Set LockWindowOutlineStyleActiveInactive
    */
    void setLockWindowOutlineStyleActiveInactive( bool v )
    {
      if (!isLockWindowOutlineStyleActiveInactiveImmutable())
        mLockWindowOutlineStyleActiveInactive = v;
    }

    /**
      Get LockWindowOutlineStyleActiveInactive
    */
    bool lockWindowOutlineStyleActiveInactive() const
    {
      return mLockWindowOutlineStyleActiveInactive;
    }

    /**
      Is LockWindowOutlineStyleActiveInactive Immutable
    */
    bool isLockWindowOutlineStyleActiveInactiveImmutable() const
    {
      return isImmutable( QStringLiteral( "LockWindowOutlineStyleActiveInactive" ) );
    }

    /**
      Set WindowOutlineCustomColor$(WindowOutlineCustomColorActive)
    */
    void setWindowOutlineCustomColor( int i, const QColor & v )
    {
      if (!isWindowOutlineCustomColorImmutable( i ))
        mWindowOutlineCustomColor[i] = v;
    }

    /**
      Get WindowOutlineCustomColor$(WindowOutlineCustomColorActive)
    */
    QColor windowOutlineCustomColor( int i ) const
    {
      return mWindowOutlineCustomColor[i];
    }

    /**
      Is WindowOutlineCustomColor$(WindowOutlineCustomColorActive) Immutable
    */
    bool isWindowOutlineCustomColorImmutable( int i ) const
    {
      return isImmutable( QStringLiteral( "WindowOutlineCustomColor%1" ).arg( QLatin1String( EnumWindowOutlineCustomColorActive::enumToString[i] ) ) );
    }

    /**
      Set LockWindowOutlineCustomColorActiveInactive
    */
    void setLockWindowOutlineCustomColorActiveInactive( bool v )
    {
      if (!isLockWindowOutlineCustomColorActiveInactiveImmutable())
        mLockWindowOutlineCustomColorActiveInactive = v;
    }

    /**
      Get LockWindowOutlineCustomColorActiveInactive
    */
    bool lockWindowOutlineCustomColorActiveInactive() const
    {
      return mLockWindowOutlineCustomColorActiveInactive;
    }

    /**
      Is LockWindowOutlineCustomColorActiveInactive Immutable
    */
    bool isLockWindowOutlineCustomColorActiveInactiveImmutable() const
    {
      return isImmutable( QStringLiteral( "LockWindowOutlineCustomColorActiveInactive" ) );
    }

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

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

      if (!isWindowOutlineShadowColorOpacityImmutable())
        mWindowOutlineShadowColorOpacity = v;
    }

    /**
      Get WindowOutlineShadowColorOpacity
    */
    int windowOutlineShadowColorOpacity() const
    {
      return mWindowOutlineShadowColorOpacity;
    }

    /**
      Is WindowOutlineShadowColorOpacity Immutable
    */
    bool isWindowOutlineShadowColorOpacityImmutable() const
    {
      return isImmutable( QStringLiteral( "WindowOutlineShadowColorOpacity" ) );
    }

    /**
      Set WindowOutlineContrastOpacity$(WindowOutlineContrastOpacityActive)
    */
    void setWindowOutlineContrastOpacity( int i, int v )
    {
      if (v < 0)
      {
        qDebug() << "setWindowOutlineContrastOpacity: value " << v << " is less than the minimum value of 0";
        v = 0;
      }

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

      if (!isWindowOutlineContrastOpacityImmutable( i ))
        mWindowOutlineContrastOpacity[i] = v;
    }

    /**
      Get WindowOutlineContrastOpacity$(WindowOutlineContrastOpacityActive)
    */
    int windowOutlineContrastOpacity( int i ) const
    {
      return mWindowOutlineContrastOpacity[i];
    }

    /**
      Is WindowOutlineContrastOpacity$(WindowOutlineContrastOpacityActive) Immutable
    */
    bool isWindowOutlineContrastOpacityImmutable( int i ) const
    {
      return isImmutable( QStringLiteral( "WindowOutlineContrastOpacity%1" ).arg( QLatin1String( EnumWindowOutlineContrastOpacityActive::enumToString[i] ) ) );
    }

    /**
      Set WindowOutlineAccentColorOpacity$(WindowOutlineAccentColorOpacityActive)
    */
    void setWindowOutlineAccentColorOpacity( int i, int v )
    {
      if (v < 0)
      {
        qDebug() << "setWindowOutlineAccentColorOpacity: value " << v << " is less than the minimum value of 0";
        v = 0;
      }

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

      if (!isWindowOutlineAccentColorOpacityImmutable( i ))
        mWindowOutlineAccentColorOpacity[i] = v;
    }

    /**
      Get WindowOutlineAccentColorOpacity$(WindowOutlineAccentColorOpacityActive)
    */
    int windowOutlineAccentColorOpacity( int i ) const
    {
      return mWindowOutlineAccentColorOpacity[i];
    }

    /**
      Is WindowOutlineAccentColorOpacity$(WindowOutlineAccentColorOpacityActive) Immutable
    */
    bool isWindowOutlineAccentColorOpacityImmutable( int i ) const
    {
      return isImmutable( QStringLiteral( "WindowOutlineAccentColorOpacity%1" ).arg( QLatin1String( EnumWindowOutlineAccentColorOpacityActive::enumToString[i] ) ) );
    }

    /**
      Set WindowOutlineAccentWithContrastOpacity$(WindowOutlineAccentWithContrastOpacityActive)
    */
    void setWindowOutlineAccentWithContrastOpacity( int i, int v )
    {
      if (v < 0)
      {
        qDebug() << "setWindowOutlineAccentWithContrastOpacity: value " << v << " is less than the minimum value of 0";
        v = 0;
      }

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

      if (!isWindowOutlineAccentWithContrastOpacityImmutable( i ))
        mWindowOutlineAccentWithContrastOpacity[i] = v;
    }

    /**
      Get WindowOutlineAccentWithContrastOpacity$(WindowOutlineAccentWithContrastOpacityActive)
    */
    int windowOutlineAccentWithContrastOpacity( int i ) const
    {
      return mWindowOutlineAccentWithContrastOpacity[i];
    }

    /**
      Is WindowOutlineAccentWithContrastOpacity$(WindowOutlineAccentWithContrastOpacityActive) Immutable
    */
    bool isWindowOutlineAccentWithContrastOpacityImmutable( int i ) const
    {
      return isImmutable( QStringLiteral( "WindowOutlineAccentWithContrastOpacity%1" ).arg( QLatin1String( EnumWindowOutlineAccentWithContrastOpacityActive::enumToString[i] ) ) );
    }

    /**
      Set WindowOutlineCustomColorOpacity$(WindowOutlineCustomColorOpacityActive)
    */
    void setWindowOutlineCustomColorOpacity( int i, int v )
    {
      if (v < 0)
      {
        qDebug() << "setWindowOutlineCustomColorOpacity: value " << v << " is less than the minimum value of 0";
        v = 0;
      }

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

      if (!isWindowOutlineCustomColorOpacityImmutable( i ))
        mWindowOutlineCustomColorOpacity[i] = v;
    }

    /**
      Get WindowOutlineCustomColorOpacity$(WindowOutlineCustomColorOpacityActive)
    */
    int windowOutlineCustomColorOpacity( int i ) const
    {
      return mWindowOutlineCustomColorOpacity[i];
    }

    /**
      Is WindowOutlineCustomColorOpacity$(WindowOutlineCustomColorOpacityActive) Immutable
    */
    bool isWindowOutlineCustomColorOpacityImmutable( int i ) const
    {
      return isImmutable( QStringLiteral( "WindowOutlineCustomColorOpacity%1" ).arg( QLatin1String( EnumWindowOutlineCustomColorOpacityActive::enumToString[i] ) ) );
    }

    /**
      Set WindowOutlineCustomWithContrastOpacity$(WindowOutlineCustomWithContrastOpacityActive)
    */
    void setWindowOutlineCustomWithContrastOpacity( int i, int v )
    {
      if (v < 0)
      {
        qDebug() << "setWindowOutlineCustomWithContrastOpacity: value " << v << " is less than the minimum value of 0";
        v = 0;
      }

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

      if (!isWindowOutlineCustomWithContrastOpacityImmutable( i ))
        mWindowOutlineCustomWithContrastOpacity[i] = v;
    }

    /**
      Get WindowOutlineCustomWithContrastOpacity$(WindowOutlineCustomWithContrastOpacityActive)
    */
    int windowOutlineCustomWithContrastOpacity( int i ) const
    {
      return mWindowOutlineCustomWithContrastOpacity[i];
    }

    /**
      Is WindowOutlineCustomWithContrastOpacity$(WindowOutlineCustomWithContrastOpacityActive) Immutable
    */
    bool isWindowOutlineCustomWithContrastOpacityImmutable( int i ) const
    {
      return isImmutable( QStringLiteral( "WindowOutlineCustomWithContrastOpacity%1" ).arg( QLatin1String( EnumWindowOutlineCustomWithContrastOpacityActive::enumToString[i] ) ) );
    }

    /**
      Set ShadowStrength
    */
    void setShadowStrength( int v )
    {
      if (v < 25)
      {
        qDebug() << "setShadowStrength: value " << v << " is less than the minimum value of 25";
        v = 25;
      }

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

      if (!isShadowStrengthImmutable())
        mShadowStrength = v;
    }

    /**
      Get ShadowStrength
    */
    int shadowStrength() const
    {
      return mShadowStrength;
    }

    /**
      Is ShadowStrength Immutable
    */
    bool isShadowStrengthImmutable() const
    {
      return isImmutable( QStringLiteral( "ShadowStrength" ) );
    }

    /**
      Set ShadowSize
    */
    void setShadowSize( int v )
    {
      if (!isShadowSizeImmutable())
        mShadowSize = v;
    }

    /**
      Get ShadowSize
    */
    int shadowSize() const
    {
      return mShadowSize;
    }

    /**
      Is ShadowSize Immutable
    */
    bool isShadowSizeImmutable() const
    {
      return isImmutable( QStringLiteral( "ShadowSize" ) );
    }

    /**
      Set ShadowColor
    */
    void setShadowColor( const QColor & v )
    {
      if (!isShadowColorImmutable())
        mShadowColor = v;
    }

    /**
      Get ShadowColor
    */
    QColor shadowColor() const
    {
      return mShadowColor;
    }

    /**
      Is ShadowColor Immutable
    */
    bool isShadowColorImmutable() const
    {
      return isImmutable( QStringLiteral( "ShadowColor" ) );
    }

    /**
      Set HideTitleBar
    */
    void setHideTitleBar( int v )
    {
      if (!isHideTitleBarImmutable())
        mHideTitleBar = v;
    }

    /**
      Get HideTitleBar
    */
    int hideTitleBar() const
    {
      return mHideTitleBar;
    }

    /**
      Is HideTitleBar Immutable
    */
    bool isHideTitleBarImmutable() const
    {
      return isImmutable( QStringLiteral( "HideTitleBar" ) );
    }

    /**
      Set OpaqueTitleBar
    */
    void setOpaqueTitleBar( bool v )
    {
      if (!isOpaqueTitleBarImmutable())
        mOpaqueTitleBar = v;
    }

    /**
      Get OpaqueTitleBar
    */
    bool opaqueTitleBar() const
    {
      return mOpaqueTitleBar;
    }

    /**
      Is OpaqueTitleBar Immutable
    */
    bool isOpaqueTitleBarImmutable() const
    {
      return isImmutable( QStringLiteral( "OpaqueTitleBar" ) );
    }

    /**
      Set ExceptionMatchTitleBarToApplicationColor
    */
    void setExceptionMatchTitleBarToApplicationColor( bool v )
    {
      if (!isExceptionMatchTitleBarToApplicationColorImmutable())
        mExceptionMatchTitleBarToApplicationColor = v;
    }

    /**
      Get ExceptionMatchTitleBarToApplicationColor
    */
    bool exceptionMatchTitleBarToApplicationColor() const
    {
      return mExceptionMatchTitleBarToApplicationColor;
    }

    /**
      Is ExceptionMatchTitleBarToApplicationColor Immutable
    */
    bool isExceptionMatchTitleBarToApplicationColorImmutable() const
    {
      return isImmutable( QStringLiteral( "ExceptionMatchTitleBarToApplicationColor" ) );
    }

    /**
      Set PreventApplyOpacityToHeader
    */
    void setPreventApplyOpacityToHeader( bool v )
    {
      if (!isPreventApplyOpacityToHeaderImmutable())
        mPreventApplyOpacityToHeader = v;
    }

    /**
      Get PreventApplyOpacityToHeader
    */
    bool preventApplyOpacityToHeader() const
    {
      return mPreventApplyOpacityToHeader;
    }

    /**
      Is PreventApplyOpacityToHeader Immutable
    */
    bool isPreventApplyOpacityToHeaderImmutable() const
    {
      return isImmutable( QStringLiteral( "PreventApplyOpacityToHeader" ) );
    }

    /**
      Set ExceptionProgramNamePattern
    */
    void setExceptionProgramNamePattern( const QString & v )
    {
      if (!isExceptionProgramNamePatternImmutable())
        mExceptionProgramNamePattern = v;
    }

    /**
      Get ExceptionProgramNamePattern
    */
    QString exceptionProgramNamePattern() const
    {
      return mExceptionProgramNamePattern;
    }

    /**
      Is ExceptionProgramNamePattern Immutable
    */
    bool isExceptionProgramNamePatternImmutable() const
    {
      return isImmutable( QStringLiteral( "ExceptionProgramNamePattern" ) );
    }

    /**
      Set ExceptionWindowPropertyType
    */
    void setExceptionWindowPropertyType( int v )
    {
      if (!isExceptionWindowPropertyTypeImmutable())
        mExceptionWindowPropertyType = v;
    }

    /**
      Get ExceptionWindowPropertyType
    */
    int exceptionWindowPropertyType() const
    {
      return mExceptionWindowPropertyType;
    }

    /**
      Is ExceptionWindowPropertyType Immutable
    */
    bool isExceptionWindowPropertyTypeImmutable() const
    {
      return isImmutable( QStringLiteral( "ExceptionWindowPropertyType" ) );
    }

    /**
      Set ExceptionWindowPropertyPattern
    */
    void setExceptionWindowPropertyPattern( const QString & v )
    {
      if (!isExceptionWindowPropertyPatternImmutable())
        mExceptionWindowPropertyPattern = v;
    }

    /**
      Get ExceptionWindowPropertyPattern
    */
    QString exceptionWindowPropertyPattern() const
    {
      return mExceptionWindowPropertyPattern;
    }

    /**
      Is ExceptionWindowPropertyPattern Immutable
    */
    bool isExceptionWindowPropertyPatternImmutable() const
    {
      return isImmutable( QStringLiteral( "ExceptionWindowPropertyPattern" ) );
    }

    /**
      Set ExceptionWindowsBehindOnly
    */
    void setExceptionWindowsBehindOnly( bool v )
    {
      if (!isExceptionWindowsBehindOnlyImmutable())
        mExceptionWindowsBehindOnly = v;
    }

    /**
      Get ExceptionWindowsBehindOnly
    */
    bool exceptionWindowsBehindOnly() const
    {
      return mExceptionWindowsBehindOnly;
    }

    /**
      Is ExceptionWindowsBehindOnly Immutable
    */
    bool isExceptionWindowsBehindOnlyImmutable() const
    {
      return isImmutable( QStringLiteral( "ExceptionWindowsBehindOnly" ) );
    }

    /**
      Set Enabled
    */
    void setEnabled( bool v )
    {
      if (!isEnabledImmutable())
        mEnabled = v;
    }

    /**
      Get Enabled
    */
    bool enabled() const
    {
      return mEnabled;
    }

    /**
      Is Enabled Immutable
    */
    bool isEnabledImmutable() const
    {
      return isImmutable( QStringLiteral( "Enabled" ) );
    }

    /**
      Set ExceptionBorder
    */
    void setExceptionBorder( bool v )
    {
      if (!isExceptionBorderImmutable())
        mExceptionBorder = v;
    }

    /**
      Get ExceptionBorder
    */
    bool exceptionBorder() const
    {
      return mExceptionBorder;
    }

    /**
      Is ExceptionBorder Immutable
    */
    bool isExceptionBorderImmutable() const
    {
      return isImmutable( QStringLiteral( "ExceptionBorder" ) );
    }

    /**
      Set BorderSize
    */
    void setBorderSize( int v )
    {
      if (!isBorderSizeImmutable())
        mBorderSize = v;
    }

    /**
      Get BorderSize
    */
    int borderSize() const
    {
      return mBorderSize;
    }

    /**
      Is BorderSize Immutable
    */
    bool isBorderSizeImmutable() const
    {
      return isImmutable( QStringLiteral( "BorderSize" ) );
    }

    /**
      Set ExceptionPreset
    */
    void setExceptionPreset( const QString & v )
    {
      if (!isExceptionPresetImmutable())
        mExceptionPreset = v;
    }

    /**
      Get ExceptionPreset
    */
    QString exceptionPreset() const
    {
      return mExceptionPreset;
    }

    /**
      Is ExceptionPreset Immutable
    */
    bool isExceptionPresetImmutable() const
    {
      return isImmutable( QStringLiteral( "ExceptionPreset" ) );
    }

  protected:

    // Global
    QString mLookAndFeelSet;
    QString mRefreshedConfig;

    // Windeco
    int mButtonIconStyle;
    int mIconSize;
    int mSystemIconSize;
    bool mForceColorizeSystemIcons;
    int mBoldButtonIcons;
    int mButtonShape;
    bool mMatchTitleBarToApplicationColor;
    bool mDrawBackgroundGradient;
    bool mDrawTitleBarSeparator;
    bool mBoldTitle;
    bool mUnderlineTitle;
    double mWindowCornerRadius;
    bool mRoundAllCornersWhenNoBorders;
    bool mUseTitleBarColorForAllBorders;
    bool mDrawBorderOnMaximizedWindows;
    bool mColorizeWindowOutlineWithButton;
    bool mAnimationsEnabled;
    int mAnimationsSpeedRelativeSystem;

    // SystemIconGeneration
    QString mKlassyIconThemeInherits;
    QString mKlassyDarkIconThemeInherits;

    // ButtonSizing
    int mScaleBackgroundPercent;
    int mButtonSpacingLeft;
    int mButtonSpacingRight;
    bool mLockButtonSpacingLeftRight;
    int mFullHeightButtonWidthMarginLeft;
    int mFullHeightButtonWidthMarginRight;
    int mCloseFullHeightButtonWidthMarginRelative;
    bool mLockFullHeightButtonWidthMargins;
    int mFullHeightButtonSpacingLeft;
    int mFullHeightButtonSpacingRight;
    bool mLockFullHeightButtonSpacingLeftRight;
    int mButtonCornerRadius;
    double mButtonCustomCornerRadius;
    double mIntegratedRoundedRectangleBottomPadding;
    int mSpacerButtonWidthRelative;
    int mScaleTouchMode;

    // ButtonColors
    bool mLockButtonColorsActiveInactive;
    bool mButtonColorsInactiveSameHoverPress;
    int mButtonIconColors[2];
    int mCloseButtonIconColor[2];
    int mOnPoorIconContrast[2];
    double mPoorIconContrastThreshold[2];
    int mButtonBackgroundColors[2];
    bool mNegativeCloseBackgroundHoverPress[2];
    bool mUseHoverAccent[2];
    bool mAdjustBackgroundColorOnPoorContrast[2];
    double mPoorBackgroundContrastThreshold[2];
    int mButtonIconOpacity[2];
    int mButtonBackgroundOpacity[2];
    QString mButtonOverrideColorsActive[10];
    QString mButtonOverrideColorsInactive[10];
    QString mButtonOverrideColorsLockStates[2];

    // ButtonBehaviour
    bool mShowIconOnPress[2];
    bool mShowBackgroundOnPress[2];
    bool mShowOutlineOnPress[2];
    bool mShowIconOnHover[2];
    bool mShowBackgroundOnHover[2];
    bool mShowOutlineOnHover[2];
    bool mShowIconNormally[2];
    bool mShowBackgroundNormally[2];
    bool mShowOutlineNormally[2];
    int mVaryColorIcon[2];
    int mVaryColorBackground[2];
    int mVaryColorOutline[2];
    int mButtonStateChecked[2];
    bool mShowCloseIconOnPress[2];
    bool mShowCloseBackgroundOnPress[2];
    bool mShowCloseOutlineOnPress[2];
    bool mShowCloseIconOnHover[2];
    bool mShowCloseBackgroundOnHover[2];
    bool mShowCloseOutlineOnHover[2];
    bool mShowCloseIconNormally[2];
    bool mShowCloseBackgroundNormally[2];
    bool mShowCloseOutlineNormally[2];
    int mVaryColorCloseIcon[2];
    int mVaryColorCloseBackground[2];
    int mVaryColorCloseOutline[2];
    bool mLockCloseButtonBehaviour[2];
    bool mLockButtonBehaviourActiveInactive;
    bool mUnisonHovering;

    // TitleBarSpacing
    double mTitleBarTopMargin;
    double mTitleBarBottomMargin;
    bool mLockTitleBarTopBottomMargins;
    int mTitleBarLeftMargin;
    int mTitleBarRightMargin;
    bool mLockTitleBarLeftRightMargins;
    int mTitleAlignment;
    int mTitleSidePadding;
    int mPercentMaximizedTopBottomMargins;

    // TitleBarOpacity
    int mActiveTitleBarOpacity;
    int mInactiveTitleBarOpacity;
    bool mOpaqueMaximizedTitleBars;
    bool mBlurTransparentTitleBars;
    bool mApplyOpacityToHeader;
    bool mOverrideActiveTitleBarOpacity;
    bool mOverrideInactiveTitleBarOpacity;

    // WindowOutlineStyle
    double mWindowOutlineThickness;
    bool mWindowOutlineSnapToWholePixel;
    bool mWindowOutlineOverlap;
    int mWindowOutlineStyle[2];
    bool mLockWindowOutlineStyleActiveInactive;
    QColor mWindowOutlineCustomColor[2];
    bool mLockWindowOutlineCustomColorActiveInactive;
    int mWindowOutlineShadowColorOpacity;
    int mWindowOutlineContrastOpacity[2];
    int mWindowOutlineAccentColorOpacity[2];
    int mWindowOutlineAccentWithContrastOpacity[2];
    int mWindowOutlineCustomColorOpacity[2];
    int mWindowOutlineCustomWithContrastOpacity[2];

    // ShadowStyle
    int mShadowStrength;
    int mShadowSize;
    QColor mShadowColor;

    // Exceptions
    int mHideTitleBar;
    bool mOpaqueTitleBar;
    bool mExceptionMatchTitleBarToApplicationColor;
    bool mPreventApplyOpacityToHeader;
    QString mExceptionProgramNamePattern;
    int mExceptionWindowPropertyType;
    QString mExceptionWindowPropertyPattern;
    bool mExceptionWindowsBehindOnly;
    bool mEnabled;
    bool mExceptionBorder;
    int mBorderSize;
    QString mExceptionPreset;

  private:
};

}

#endif

