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

#include "rules.h"
#include <netwm_def.h>

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

namespace KWin {

class RuleSettings : public KConfigSkeleton
{
  public:

    RuleSettings( KSharedConfig::Ptr config,  const QString & ruleDescriptionOrNumber, QObject *parent = nullptr );
    ~RuleSettings() override;

    /**
      Set Rule description
    */
    void setDescription( const QString & v )
    {
      if (!isDescriptionImmutable())
        mDescription = v;
    }

    /**
      Get Rule description
    */
    QString description() const
    {
      return mDescription;
    }

    /**
      Is Rule description Immutable
    */
    bool isDescriptionImmutable() const
    {
      return isImmutable( QStringLiteral( "description" ) );
    }

    /**
      Set Rule description (legacy)
    */
    void setDescriptionLegacy( const QString & v )
    {
      if (!isDescriptionLegacyImmutable())
        mDescriptionLegacy = v;
    }

    /**
      Get Rule description (legacy)
    */
    QString descriptionLegacy() const
    {
      return mDescriptionLegacy;
    }

    /**
      Is Rule description (legacy) Immutable
    */
    bool isDescriptionLegacyImmutable() const
    {
      return isImmutable( QStringLiteral( "descriptionLegacy" ) );
    }

    /**
      Set Delete this rule (for use in imports)
    */
    void setDeleteRule( bool v )
    {
      if (!isDeleteRuleImmutable())
        mDeleteRule = v;
    }

    /**
      Get Delete this rule (for use in imports)
    */
    bool deleteRule() const
    {
      return mDeleteRule;
    }

    /**
      Is Delete this rule (for use in imports) Immutable
    */
    bool isDeleteRuleImmutable() const
    {
      return isImmutable( QStringLiteral( "DeleteRule" ) );
    }

    /**
      Set This rule is enabled
    */
    void setEnabled( bool v )
    {
      if (!isEnabledImmutable())
        mEnabled = v;
    }

    /**
      Get This rule is enabled
    */
    bool enabled() const
    {
      return mEnabled;
    }

    /**
      Is This rule is enabled Immutable
    */
    bool isEnabledImmutable() const
    {
      return isImmutable( QStringLiteral( "enabled" ) );
    }

    /**
      Set Window class (application)
    */
    void setWmclass( const QString & v )
    {
      if (!isWmclassImmutable())
        mWmclass = v;
    }

    /**
      Get Window class (application)
    */
    QString wmclass() const
    {
      return mWmclass;
    }

    /**
      Is Window class (application) Immutable
    */
    bool isWmclassImmutable() const
    {
      return isImmutable( QStringLiteral( "wmclass" ) );
    }

    /**
      Set Window class string match type
    */
    void setWmclassmatch( int v )
    {
      if (v < Rules::FirstStringMatch)
      {
        qDebug() << "setWmclassmatch: value " << v << " is less than the minimum value of Rules::FirstStringMatch";
        v = Rules::FirstStringMatch;
      }

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

      if (!isWmclassmatchImmutable())
        mWmclassmatch = v;
    }

    /**
      Get Window class string match type
    */
    int wmclassmatch() const
    {
      return mWmclassmatch;
    }

    /**
      Is Window class string match type Immutable
    */
    bool isWmclassmatchImmutable() const
    {
      return isImmutable( QStringLiteral( "wmclassmatch" ) );
    }

    /**
      Set Match whole window class
    */
    void setWmclasscomplete( bool v )
    {
      if (!isWmclasscompleteImmutable())
        mWmclasscomplete = v;
    }

    /**
      Get Match whole window class
    */
    bool wmclasscomplete() const
    {
      return mWmclasscomplete;
    }

    /**
      Is Match whole window class Immutable
    */
    bool isWmclasscompleteImmutable() const
    {
      return isImmutable( QStringLiteral( "wmclasscomplete" ) );
    }

    /**
      Set Window role
    */
    void setWindowrole( const QString & v )
    {
      if (!isWindowroleImmutable())
        mWindowrole = v;
    }

    /**
      Get Window role
    */
    QString windowrole() const
    {
      return mWindowrole;
    }

    /**
      Is Window role Immutable
    */
    bool isWindowroleImmutable() const
    {
      return isImmutable( QStringLiteral( "windowrole" ) );
    }

    /**
      Set Window role string match type
    */
    void setWindowrolematch( int v )
    {
      if (v < Rules::FirstStringMatch)
      {
        qDebug() << "setWindowrolematch: value " << v << " is less than the minimum value of Rules::FirstStringMatch";
        v = Rules::FirstStringMatch;
      }

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

      if (!isWindowrolematchImmutable())
        mWindowrolematch = v;
    }

    /**
      Get Window role string match type
    */
    int windowrolematch() const
    {
      return mWindowrolematch;
    }

    /**
      Is Window role string match type Immutable
    */
    bool isWindowrolematchImmutable() const
    {
      return isImmutable( QStringLiteral( "windowrolematch" ) );
    }

    /**
      Set Window title
    */
    void setTitle( const QString & v )
    {
      if (!isTitleImmutable())
        mTitle = v;
    }

    /**
      Get Window title
    */
    QString title() const
    {
      return mTitle;
    }

    /**
      Is Window title Immutable
    */
    bool isTitleImmutable() const
    {
      return isImmutable( QStringLiteral( "title" ) );
    }

    /**
      Set Window title string match type
    */
    void setTitlematch( int v )
    {
      if (v < Rules::FirstStringMatch)
      {
        qDebug() << "setTitlematch: value " << v << " is less than the minimum value of Rules::FirstStringMatch";
        v = Rules::FirstStringMatch;
      }

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

      if (!isTitlematchImmutable())
        mTitlematch = v;
    }

    /**
      Get Window title string match type
    */
    int titlematch() const
    {
      return mTitlematch;
    }

    /**
      Is Window title string match type Immutable
    */
    bool isTitlematchImmutable() const
    {
      return isImmutable( QStringLiteral( "titlematch" ) );
    }

    /**
      Set Machine (hostname)
    */
    void setClientmachine( const QString & v )
    {
      if (!isClientmachineImmutable())
        mClientmachine = v;
    }

    /**
      Get Machine (hostname)
    */
    QString clientmachine() const
    {
      return mClientmachine;
    }

    /**
      Is Machine (hostname) Immutable
    */
    bool isClientmachineImmutable() const
    {
      return isImmutable( QStringLiteral( "clientmachine" ) );
    }

    /**
      Set Machine string match type
    */
    void setClientmachinematch( int v )
    {
      if (v < Rules::FirstStringMatch)
      {
        qDebug() << "setClientmachinematch: value " << v << " is less than the minimum value of Rules::FirstStringMatch";
        v = Rules::FirstStringMatch;
      }

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

      if (!isClientmachinematchImmutable())
        mClientmachinematch = v;
    }

    /**
      Get Machine string match type
    */
    int clientmachinematch() const
    {
      return mClientmachinematch;
    }

    /**
      Is Machine string match type Immutable
    */
    bool isClientmachinematchImmutable() const
    {
      return isImmutable( QStringLiteral( "clientmachinematch" ) );
    }

    /**
      Set Window tag
    */
    void setTag( const QString & v )
    {
      if (!isTagImmutable())
        mTag = v;
    }

    /**
      Get Window tag
    */
    QString tag() const
    {
      return mTag;
    }

    /**
      Is Window tag Immutable
    */
    bool isTagImmutable() const
    {
      return isImmutable( QStringLiteral( "tag" ) );
    }

    /**
      Set Window tag string match type
    */
    void setTagmatch( int v )
    {
      if (v < Rules::FirstStringMatch)
      {
        qDebug() << "setTagmatch: value " << v << " is less than the minimum value of Rules::FirstStringMatch";
        v = Rules::FirstStringMatch;
      }

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

      if (!isTagmatchImmutable())
        mTagmatch = v;
    }

    /**
      Get Window tag string match type
    */
    int tagmatch() const
    {
      return mTagmatch;
    }

    /**
      Is Window tag string match type Immutable
    */
    bool isTagmatchImmutable() const
    {
      return isImmutable( QStringLiteral( "tagmatch" ) );
    }

    /**
      Set Has parent window
    */
    void setHastransientparent( bool v )
    {
      if (!isHastransientparentImmutable())
        mHastransientparent = v;
    }

    /**
      Get Has parent window
    */
    bool hastransientparent() const
    {
      return mHastransientparent;
    }

    /**
      Is Has parent window Immutable
    */
    bool isHastransientparentImmutable() const
    {
      return isImmutable( QStringLiteral( "hastransientparent" ) );
    }

    /**
      Set Has parent window match type
    */
    void setHastransientparentmatch( int v )
    {
      if (v < Rules::FirstBoolMatch)
      {
        qDebug() << "setHastransientparentmatch: value " << v << " is less than the minimum value of Rules::FirstBoolMatch";
        v = Rules::FirstBoolMatch;
      }

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

      if (!isHastransientparentmatchImmutable())
        mHastransientparentmatch = v;
    }

    /**
      Get Has parent window match type
    */
    int hastransientparentmatch() const
    {
      return mHastransientparentmatch;
    }

    /**
      Is Has parent window match type Immutable
    */
    bool isHastransientparentmatchImmutable() const
    {
      return isImmutable( QStringLiteral( "hastransientparentmatch" ) );
    }

    /**
      Set Window types that match
    */
    void setTypes( uint v )
    {
      if (!isTypesImmutable())
        mTypes = v;
    }

    /**
      Get Window types that match
    */
    uint types() const
    {
      return mTypes;
    }

    /**
      Is Window types that match Immutable
    */
    bool isTypesImmutable() const
    {
      return isImmutable( QStringLiteral( "types" ) );
    }

    /**
      Set Initial placement
    */
    void setPlacement( PlacementPolicy v )
    {
      if (!isPlacementImmutable())
        mPlacement = int(v);
    }

    /**
      Get Initial placement
    */
    PlacementPolicy placement() const
    {
      return static_cast<PlacementPolicy>(mPlacement);
    }

    /**
      Is Initial placement Immutable
    */
    bool isPlacementImmutable() const
    {
      return isImmutable( QStringLiteral( "placement" ) );
    }

    /**
      Set Initial placement rule type
    */
    void setPlacementrule( int v )
    {
      if (!isPlacementruleImmutable())
        mPlacementrule = v;
    }

    /**
      Get Initial placement rule type
    */
    int placementrule() const
    {
      return mPlacementrule;
    }

    /**
      Is Initial placement rule type Immutable
    */
    bool isPlacementruleImmutable() const
    {
      return isImmutable( QStringLiteral( "placementrule" ) );
    }

    /**
      Set Window position
    */
    void setPosition( const QPoint & v )
    {
      if (!isPositionImmutable())
        mPosition = v;
    }

    /**
      Get Window position
    */
    QPoint position() const
    {
      return mPosition;
    }

    /**
      Is Window position Immutable
    */
    bool isPositionImmutable() const
    {
      return isImmutable( QStringLiteral( "position" ) );
    }

    /**
      Set Window position rule type
    */
    void setPositionrule( int v )
    {
      if (v < Rules::UnusedSetRule)
      {
        qDebug() << "setPositionrule: value " << v << " is less than the minimum value of Rules::UnusedSetRule";
        v = Rules::UnusedSetRule;
      }

      if (v > static_cast<Rules::SetRule>(Rules::ForceTemporarily))
      {
        qDebug() << "setPositionrule: value " << v << " is greater than the maximum value of static_cast<Rules::SetRule>(Rules::ForceTemporarily)";
        v = static_cast<Rules::SetRule>(Rules::ForceTemporarily);
      }

      if (!isPositionruleImmutable())
        mPositionrule = v;
    }

    /**
      Get Window position rule type
    */
    int positionrule() const
    {
      return mPositionrule;
    }

    /**
      Is Window position rule type Immutable
    */
    bool isPositionruleImmutable() const
    {
      return isImmutable( QStringLiteral( "positionrule" ) );
    }

    /**
      Set Window size
    */
    void setSize( const QSize & v )
    {
      if (!isSizeImmutable())
        mSize = v;
    }

    /**
      Get Window size
    */
    QSize size() const
    {
      return mSize;
    }

    /**
      Is Window size Immutable
    */
    bool isSizeImmutable() const
    {
      return isImmutable( QStringLiteral( "size" ) );
    }

    /**
      Set Window size rule type
    */
    void setSizerule( int v )
    {
      if (v < Rules::UnusedSetRule)
      {
        qDebug() << "setSizerule: value " << v << " is less than the minimum value of Rules::UnusedSetRule";
        v = Rules::UnusedSetRule;
      }

      if (v > static_cast<Rules::SetRule>(Rules::ForceTemporarily))
      {
        qDebug() << "setSizerule: value " << v << " is greater than the maximum value of static_cast<Rules::SetRule>(Rules::ForceTemporarily)";
        v = static_cast<Rules::SetRule>(Rules::ForceTemporarily);
      }

      if (!isSizeruleImmutable())
        mSizerule = v;
    }

    /**
      Get Window size rule type
    */
    int sizerule() const
    {
      return mSizerule;
    }

    /**
      Is Window size rule type Immutable
    */
    bool isSizeruleImmutable() const
    {
      return isImmutable( QStringLiteral( "sizerule" ) );
    }

    /**
      Set Window minimum size
    */
    void setMinsize( const QSize & v )
    {
      if (!isMinsizeImmutable())
        mMinsize = v;
    }

    /**
      Get Window minimum size
    */
    QSize minsize() const
    {
      return mMinsize;
    }

    /**
      Is Window minimum size Immutable
    */
    bool isMinsizeImmutable() const
    {
      return isImmutable( QStringLiteral( "minsize" ) );
    }

    /**
      Set Window minimum size rule type
    */
    void setMinsizerule( int v )
    {
      if (!isMinsizeruleImmutable())
        mMinsizerule = v;
    }

    /**
      Get Window minimum size rule type
    */
    int minsizerule() const
    {
      return mMinsizerule;
    }

    /**
      Is Window minimum size rule type Immutable
    */
    bool isMinsizeruleImmutable() const
    {
      return isImmutable( QStringLiteral( "minsizerule" ) );
    }

    /**
      Set Window maximum size
    */
    void setMaxsize( const QSize & v )
    {
      if (!isMaxsizeImmutable())
        mMaxsize = v;
    }

    /**
      Get Window maximum size
    */
    QSize maxsize() const
    {
      return mMaxsize;
    }

    /**
      Is Window maximum size Immutable
    */
    bool isMaxsizeImmutable() const
    {
      return isImmutable( QStringLiteral( "maxsize" ) );
    }

    /**
      Set Window maximum size rule type
    */
    void setMaxsizerule( int v )
    {
      if (!isMaxsizeruleImmutable())
        mMaxsizerule = v;
    }

    /**
      Get Window maximum size rule type
    */
    int maxsizerule() const
    {
      return mMaxsizerule;
    }

    /**
      Is Window maximum size rule type Immutable
    */
    bool isMaxsizeruleImmutable() const
    {
      return isImmutable( QStringLiteral( "maxsizerule" ) );
    }

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

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

      if (!isOpacityactiveImmutable())
        mOpacityactive = v;
    }

    /**
      Get Active opacity
    */
    int opacityactive() const
    {
      return mOpacityactive;
    }

    /**
      Is Active opacity Immutable
    */
    bool isOpacityactiveImmutable() const
    {
      return isImmutable( QStringLiteral( "opacityactive" ) );
    }

    /**
      Set Active opacity rule type
    */
    void setOpacityactiverule( int v )
    {
      if (!isOpacityactiveruleImmutable())
        mOpacityactiverule = v;
    }

    /**
      Get Active opacity rule type
    */
    int opacityactiverule() const
    {
      return mOpacityactiverule;
    }

    /**
      Is Active opacity rule type Immutable
    */
    bool isOpacityactiveruleImmutable() const
    {
      return isImmutable( QStringLiteral( "opacityactiverule" ) );
    }

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

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

      if (!isOpacityinactiveImmutable())
        mOpacityinactive = v;
    }

    /**
      Get Inactive opacity
    */
    int opacityinactive() const
    {
      return mOpacityinactive;
    }

    /**
      Is Inactive opacity Immutable
    */
    bool isOpacityinactiveImmutable() const
    {
      return isImmutable( QStringLiteral( "opacityinactive" ) );
    }

    /**
      Set Inactive opacity rule type
    */
    void setOpacityinactiverule( int v )
    {
      if (!isOpacityinactiveruleImmutable())
        mOpacityinactiverule = v;
    }

    /**
      Get Inactive opacity rule type
    */
    int opacityinactiverule() const
    {
      return mOpacityinactiverule;
    }

    /**
      Is Inactive opacity rule type Immutable
    */
    bool isOpacityinactiveruleImmutable() const
    {
      return isImmutable( QStringLiteral( "opacityinactiverule" ) );
    }

    /**
      Set Ignore requested geometry
    */
    void setIgnoregeometry( bool v )
    {
      if (!isIgnoregeometryImmutable())
        mIgnoregeometry = v;
    }

    /**
      Get Ignore requested geometry
    */
    bool ignoregeometry() const
    {
      return mIgnoregeometry;
    }

    /**
      Is Ignore requested geometry Immutable
    */
    bool isIgnoregeometryImmutable() const
    {
      return isImmutable( QStringLiteral( "ignoregeometry" ) );
    }

    /**
      Set Ignore requested geometry rule type
    */
    void setIgnoregeometryrule( int v )
    {
      if (v < Rules::UnusedSetRule)
      {
        qDebug() << "setIgnoregeometryrule: value " << v << " is less than the minimum value of Rules::UnusedSetRule";
        v = Rules::UnusedSetRule;
      }

      if (v > static_cast<Rules::SetRule>(Rules::ForceTemporarily))
      {
        qDebug() << "setIgnoregeometryrule: value " << v << " is greater than the maximum value of static_cast<Rules::SetRule>(Rules::ForceTemporarily)";
        v = static_cast<Rules::SetRule>(Rules::ForceTemporarily);
      }

      if (!isIgnoregeometryruleImmutable())
        mIgnoregeometryrule = v;
    }

    /**
      Get Ignore requested geometry rule type
    */
    int ignoregeometryrule() const
    {
      return mIgnoregeometryrule;
    }

    /**
      Is Ignore requested geometry rule type Immutable
    */
    bool isIgnoregeometryruleImmutable() const
    {
      return isImmutable( QStringLiteral( "ignoregeometryrule" ) );
    }

    /**
      Set List of Desktop Ids
    */
    void setDesktops( const QStringList & v )
    {
      if (!isDesktopsImmutable())
        mDesktops = v;
    }

    /**
      Get List of Desktop Ids
    */
    QStringList desktops() const
    {
      return mDesktops;
    }

    /**
      Is List of Desktop Ids Immutable
    */
    bool isDesktopsImmutable() const
    {
      return isImmutable( QStringLiteral( "desktops" ) );
    }

    /**
      Set Desktop Ids rule type
    */
    void setDesktopsrule( int v )
    {
      if (v < Rules::UnusedSetRule)
      {
        qDebug() << "setDesktopsrule: value " << v << " is less than the minimum value of Rules::UnusedSetRule";
        v = Rules::UnusedSetRule;
      }

      if (v > static_cast<Rules::SetRule>(Rules::ForceTemporarily))
      {
        qDebug() << "setDesktopsrule: value " << v << " is greater than the maximum value of static_cast<Rules::SetRule>(Rules::ForceTemporarily)";
        v = static_cast<Rules::SetRule>(Rules::ForceTemporarily);
      }

      if (!isDesktopsruleImmutable())
        mDesktopsrule = v;
    }

    /**
      Get Desktop Ids rule type
    */
    int desktopsrule() const
    {
      return mDesktopsrule;
    }

    /**
      Is Desktop Ids rule type Immutable
    */
    bool isDesktopsruleImmutable() const
    {
      return isImmutable( QStringLiteral( "desktopsrule" ) );
    }

    /**
      Set Screen number
    */
    void setScreen( int v )
    {
      if (!isScreenImmutable())
        mScreen = v;
    }

    /**
      Get Screen number
    */
    int screen() const
    {
      return mScreen;
    }

    /**
      Is Screen number Immutable
    */
    bool isScreenImmutable() const
    {
      return isImmutable( QStringLiteral( "screen" ) );
    }

    /**
      Set Screen number rule type
    */
    void setScreenrule( int v )
    {
      if (v < Rules::UnusedSetRule)
      {
        qDebug() << "setScreenrule: value " << v << " is less than the minimum value of Rules::UnusedSetRule";
        v = Rules::UnusedSetRule;
      }

      if (v > static_cast<Rules::SetRule>(Rules::ForceTemporarily))
      {
        qDebug() << "setScreenrule: value " << v << " is greater than the maximum value of static_cast<Rules::SetRule>(Rules::ForceTemporarily)";
        v = static_cast<Rules::SetRule>(Rules::ForceTemporarily);
      }

      if (!isScreenruleImmutable())
        mScreenrule = v;
    }

    /**
      Get Screen number rule type
    */
    int screenrule() const
    {
      return mScreenrule;
    }

    /**
      Is Screen number rule type Immutable
    */
    bool isScreenruleImmutable() const
    {
      return isImmutable( QStringLiteral( "screenrule" ) );
    }

    /**
      Set Activity
    */
    void setActivity( const QStringList & v )
    {
      if (!isActivityImmutable())
        mActivity = v;
    }

    /**
      Get Activity
    */
    QStringList activity() const
    {
      return mActivity;
    }

    /**
      Is Activity Immutable
    */
    bool isActivityImmutable() const
    {
      return isImmutable( QStringLiteral( "activity" ) );
    }

    /**
      Set Activity rule type
    */
    void setActivityrule( int v )
    {
      if (v < Rules::UnusedSetRule)
      {
        qDebug() << "setActivityrule: value " << v << " is less than the minimum value of Rules::UnusedSetRule";
        v = Rules::UnusedSetRule;
      }

      if (v > static_cast<Rules::SetRule>(Rules::ForceTemporarily))
      {
        qDebug() << "setActivityrule: value " << v << " is greater than the maximum value of static_cast<Rules::SetRule>(Rules::ForceTemporarily)";
        v = static_cast<Rules::SetRule>(Rules::ForceTemporarily);
      }

      if (!isActivityruleImmutable())
        mActivityrule = v;
    }

    /**
      Get Activity rule type
    */
    int activityrule() const
    {
      return mActivityrule;
    }

    /**
      Is Activity rule type Immutable
    */
    bool isActivityruleImmutable() const
    {
      return isImmutable( QStringLiteral( "activityrule" ) );
    }

    /**
      Set Maximized vertically
    */
    void setMaximizevert( bool v )
    {
      if (!isMaximizevertImmutable())
        mMaximizevert = v;
    }

    /**
      Get Maximized vertically
    */
    bool maximizevert() const
    {
      return mMaximizevert;
    }

    /**
      Is Maximized vertically Immutable
    */
    bool isMaximizevertImmutable() const
    {
      return isImmutable( QStringLiteral( "maximizevert" ) );
    }

    /**
      Set Maximized vertically rule type
    */
    void setMaximizevertrule( int v )
    {
      if (v < Rules::UnusedSetRule)
      {
        qDebug() << "setMaximizevertrule: value " << v << " is less than the minimum value of Rules::UnusedSetRule";
        v = Rules::UnusedSetRule;
      }

      if (v > static_cast<Rules::SetRule>(Rules::ForceTemporarily))
      {
        qDebug() << "setMaximizevertrule: value " << v << " is greater than the maximum value of static_cast<Rules::SetRule>(Rules::ForceTemporarily)";
        v = static_cast<Rules::SetRule>(Rules::ForceTemporarily);
      }

      if (!isMaximizevertruleImmutable())
        mMaximizevertrule = v;
    }

    /**
      Get Maximized vertically rule type
    */
    int maximizevertrule() const
    {
      return mMaximizevertrule;
    }

    /**
      Is Maximized vertically rule type Immutable
    */
    bool isMaximizevertruleImmutable() const
    {
      return isImmutable( QStringLiteral( "maximizevertrule" ) );
    }

    /**
      Set Maximized horizontally
    */
    void setMaximizehoriz( bool v )
    {
      if (!isMaximizehorizImmutable())
        mMaximizehoriz = v;
    }

    /**
      Get Maximized horizontally
    */
    bool maximizehoriz() const
    {
      return mMaximizehoriz;
    }

    /**
      Is Maximized horizontally Immutable
    */
    bool isMaximizehorizImmutable() const
    {
      return isImmutable( QStringLiteral( "maximizehoriz" ) );
    }

    /**
      Set Maximized horizontally rule type
    */
    void setMaximizehorizrule( int v )
    {
      if (v < Rules::UnusedSetRule)
      {
        qDebug() << "setMaximizehorizrule: value " << v << " is less than the minimum value of Rules::UnusedSetRule";
        v = Rules::UnusedSetRule;
      }

      if (v > static_cast<Rules::SetRule>(Rules::ForceTemporarily))
      {
        qDebug() << "setMaximizehorizrule: value " << v << " is greater than the maximum value of static_cast<Rules::SetRule>(Rules::ForceTemporarily)";
        v = static_cast<Rules::SetRule>(Rules::ForceTemporarily);
      }

      if (!isMaximizehorizruleImmutable())
        mMaximizehorizrule = v;
    }

    /**
      Get Maximized horizontally rule type
    */
    int maximizehorizrule() const
    {
      return mMaximizehorizrule;
    }

    /**
      Is Maximized horizontally rule type Immutable
    */
    bool isMaximizehorizruleImmutable() const
    {
      return isImmutable( QStringLiteral( "maximizehorizrule" ) );
    }

    /**
      Set Minimized
    */
    void setMinimize( bool v )
    {
      if (!isMinimizeImmutable())
        mMinimize = v;
    }

    /**
      Get Minimized
    */
    bool minimize() const
    {
      return mMinimize;
    }

    /**
      Is Minimized Immutable
    */
    bool isMinimizeImmutable() const
    {
      return isImmutable( QStringLiteral( "minimize" ) );
    }

    /**
      Set Minimized rule type
    */
    void setMinimizerule( int v )
    {
      if (v < Rules::UnusedSetRule)
      {
        qDebug() << "setMinimizerule: value " << v << " is less than the minimum value of Rules::UnusedSetRule";
        v = Rules::UnusedSetRule;
      }

      if (v > static_cast<Rules::SetRule>(Rules::ForceTemporarily))
      {
        qDebug() << "setMinimizerule: value " << v << " is greater than the maximum value of static_cast<Rules::SetRule>(Rules::ForceTemporarily)";
        v = static_cast<Rules::SetRule>(Rules::ForceTemporarily);
      }

      if (!isMinimizeruleImmutable())
        mMinimizerule = v;
    }

    /**
      Get Minimized rule type
    */
    int minimizerule() const
    {
      return mMinimizerule;
    }

    /**
      Is Minimized rule type Immutable
    */
    bool isMinimizeruleImmutable() const
    {
      return isImmutable( QStringLiteral( "minimizerule" ) );
    }

    /**
      Set Skip taskbar
    */
    void setSkiptaskbar( bool v )
    {
      if (!isSkiptaskbarImmutable())
        mSkiptaskbar = v;
    }

    /**
      Get Skip taskbar
    */
    bool skiptaskbar() const
    {
      return mSkiptaskbar;
    }

    /**
      Is Skip taskbar Immutable
    */
    bool isSkiptaskbarImmutable() const
    {
      return isImmutable( QStringLiteral( "skiptaskbar" ) );
    }

    /**
      Set Skip taskbar rule type
    */
    void setSkiptaskbarrule( int v )
    {
      if (v < Rules::UnusedSetRule)
      {
        qDebug() << "setSkiptaskbarrule: value " << v << " is less than the minimum value of Rules::UnusedSetRule";
        v = Rules::UnusedSetRule;
      }

      if (v > static_cast<Rules::SetRule>(Rules::ForceTemporarily))
      {
        qDebug() << "setSkiptaskbarrule: value " << v << " is greater than the maximum value of static_cast<Rules::SetRule>(Rules::ForceTemporarily)";
        v = static_cast<Rules::SetRule>(Rules::ForceTemporarily);
      }

      if (!isSkiptaskbarruleImmutable())
        mSkiptaskbarrule = v;
    }

    /**
      Get Skip taskbar rule type
    */
    int skiptaskbarrule() const
    {
      return mSkiptaskbarrule;
    }

    /**
      Is Skip taskbar rule type Immutable
    */
    bool isSkiptaskbarruleImmutable() const
    {
      return isImmutable( QStringLiteral( "skiptaskbarrule" ) );
    }

    /**
      Set Skip pager
    */
    void setSkippager( bool v )
    {
      if (!isSkippagerImmutable())
        mSkippager = v;
    }

    /**
      Get Skip pager
    */
    bool skippager() const
    {
      return mSkippager;
    }

    /**
      Is Skip pager Immutable
    */
    bool isSkippagerImmutable() const
    {
      return isImmutable( QStringLiteral( "skippager" ) );
    }

    /**
      Set Skip pager rule type
    */
    void setSkippagerrule( int v )
    {
      if (v < Rules::UnusedSetRule)
      {
        qDebug() << "setSkippagerrule: value " << v << " is less than the minimum value of Rules::UnusedSetRule";
        v = Rules::UnusedSetRule;
      }

      if (v > static_cast<Rules::SetRule>(Rules::ForceTemporarily))
      {
        qDebug() << "setSkippagerrule: value " << v << " is greater than the maximum value of static_cast<Rules::SetRule>(Rules::ForceTemporarily)";
        v = static_cast<Rules::SetRule>(Rules::ForceTemporarily);
      }

      if (!isSkippagerruleImmutable())
        mSkippagerrule = v;
    }

    /**
      Get Skip pager rule type
    */
    int skippagerrule() const
    {
      return mSkippagerrule;
    }

    /**
      Is Skip pager rule type Immutable
    */
    bool isSkippagerruleImmutable() const
    {
      return isImmutable( QStringLiteral( "skippagerrule" ) );
    }

    /**
      Set Skip switcher
    */
    void setSkipswitcher( bool v )
    {
      if (!isSkipswitcherImmutable())
        mSkipswitcher = v;
    }

    /**
      Get Skip switcher
    */
    bool skipswitcher() const
    {
      return mSkipswitcher;
    }

    /**
      Is Skip switcher Immutable
    */
    bool isSkipswitcherImmutable() const
    {
      return isImmutable( QStringLiteral( "skipswitcher" ) );
    }

    /**
      Set Skip switcher rule type
    */
    void setSkipswitcherrule( int v )
    {
      if (v < Rules::UnusedSetRule)
      {
        qDebug() << "setSkipswitcherrule: value " << v << " is less than the minimum value of Rules::UnusedSetRule";
        v = Rules::UnusedSetRule;
      }

      if (v > static_cast<Rules::SetRule>(Rules::ForceTemporarily))
      {
        qDebug() << "setSkipswitcherrule: value " << v << " is greater than the maximum value of static_cast<Rules::SetRule>(Rules::ForceTemporarily)";
        v = static_cast<Rules::SetRule>(Rules::ForceTemporarily);
      }

      if (!isSkipswitcherruleImmutable())
        mSkipswitcherrule = v;
    }

    /**
      Get Skip switcher rule type
    */
    int skipswitcherrule() const
    {
      return mSkipswitcherrule;
    }

    /**
      Is Skip switcher rule type Immutable
    */
    bool isSkipswitcherruleImmutable() const
    {
      return isImmutable( QStringLiteral( "skipswitcherrule" ) );
    }

    /**
      Set Keep above
    */
    void setAbove( bool v )
    {
      if (!isAboveImmutable())
        mAbove = v;
    }

    /**
      Get Keep above
    */
    bool above() const
    {
      return mAbove;
    }

    /**
      Is Keep above Immutable
    */
    bool isAboveImmutable() const
    {
      return isImmutable( QStringLiteral( "above" ) );
    }

    /**
      Set Keep above rule type
    */
    void setAboverule( int v )
    {
      if (v < Rules::UnusedSetRule)
      {
        qDebug() << "setAboverule: value " << v << " is less than the minimum value of Rules::UnusedSetRule";
        v = Rules::UnusedSetRule;
      }

      if (v > static_cast<Rules::SetRule>(Rules::ForceTemporarily))
      {
        qDebug() << "setAboverule: value " << v << " is greater than the maximum value of static_cast<Rules::SetRule>(Rules::ForceTemporarily)";
        v = static_cast<Rules::SetRule>(Rules::ForceTemporarily);
      }

      if (!isAboveruleImmutable())
        mAboverule = v;
    }

    /**
      Get Keep above rule type
    */
    int aboverule() const
    {
      return mAboverule;
    }

    /**
      Is Keep above rule type Immutable
    */
    bool isAboveruleImmutable() const
    {
      return isImmutable( QStringLiteral( "aboverule" ) );
    }

    /**
      Set Keep below
    */
    void setBelow( bool v )
    {
      if (!isBelowImmutable())
        mBelow = v;
    }

    /**
      Get Keep below
    */
    bool below() const
    {
      return mBelow;
    }

    /**
      Is Keep below Immutable
    */
    bool isBelowImmutable() const
    {
      return isImmutable( QStringLiteral( "below" ) );
    }

    /**
      Set Keep below rule type
    */
    void setBelowrule( int v )
    {
      if (v < Rules::UnusedSetRule)
      {
        qDebug() << "setBelowrule: value " << v << " is less than the minimum value of Rules::UnusedSetRule";
        v = Rules::UnusedSetRule;
      }

      if (v > static_cast<Rules::SetRule>(Rules::ForceTemporarily))
      {
        qDebug() << "setBelowrule: value " << v << " is greater than the maximum value of static_cast<Rules::SetRule>(Rules::ForceTemporarily)";
        v = static_cast<Rules::SetRule>(Rules::ForceTemporarily);
      }

      if (!isBelowruleImmutable())
        mBelowrule = v;
    }

    /**
      Get Keep below rule type
    */
    int belowrule() const
    {
      return mBelowrule;
    }

    /**
      Is Keep below rule type Immutable
    */
    bool isBelowruleImmutable() const
    {
      return isImmutable( QStringLiteral( "belowrule" ) );
    }

    /**
      Set Fullscreen
    */
    void setFullscreen( bool v )
    {
      if (!isFullscreenImmutable())
        mFullscreen = v;
    }

    /**
      Get Fullscreen
    */
    bool fullscreen() const
    {
      return mFullscreen;
    }

    /**
      Is Fullscreen Immutable
    */
    bool isFullscreenImmutable() const
    {
      return isImmutable( QStringLiteral( "fullscreen" ) );
    }

    /**
      Set Fullscreen rule type
    */
    void setFullscreenrule( int v )
    {
      if (v < Rules::UnusedSetRule)
      {
        qDebug() << "setFullscreenrule: value " << v << " is less than the minimum value of Rules::UnusedSetRule";
        v = Rules::UnusedSetRule;
      }

      if (v > static_cast<Rules::SetRule>(Rules::ForceTemporarily))
      {
        qDebug() << "setFullscreenrule: value " << v << " is greater than the maximum value of static_cast<Rules::SetRule>(Rules::ForceTemporarily)";
        v = static_cast<Rules::SetRule>(Rules::ForceTemporarily);
      }

      if (!isFullscreenruleImmutable())
        mFullscreenrule = v;
    }

    /**
      Get Fullscreen rule type
    */
    int fullscreenrule() const
    {
      return mFullscreenrule;
    }

    /**
      Is Fullscreen rule type Immutable
    */
    bool isFullscreenruleImmutable() const
    {
      return isImmutable( QStringLiteral( "fullscreenrule" ) );
    }

    /**
      Set No titlebar and frame
    */
    void setNoborder( bool v )
    {
      if (!isNoborderImmutable())
        mNoborder = v;
    }

    /**
      Get No titlebar and frame
    */
    bool noborder() const
    {
      return mNoborder;
    }

    /**
      Is No titlebar and frame Immutable
    */
    bool isNoborderImmutable() const
    {
      return isImmutable( QStringLiteral( "noborder" ) );
    }

    /**
      Set No titlebar rule type
    */
    void setNoborderrule( int v )
    {
      if (v < Rules::UnusedSetRule)
      {
        qDebug() << "setNoborderrule: value " << v << " is less than the minimum value of Rules::UnusedSetRule";
        v = Rules::UnusedSetRule;
      }

      if (v > static_cast<Rules::SetRule>(Rules::ForceTemporarily))
      {
        qDebug() << "setNoborderrule: value " << v << " is greater than the maximum value of static_cast<Rules::SetRule>(Rules::ForceTemporarily)";
        v = static_cast<Rules::SetRule>(Rules::ForceTemporarily);
      }

      if (!isNoborderruleImmutable())
        mNoborderrule = v;
    }

    /**
      Get No titlebar rule type
    */
    int noborderrule() const
    {
      return mNoborderrule;
    }

    /**
      Is No titlebar rule type Immutable
    */
    bool isNoborderruleImmutable() const
    {
      return isImmutable( QStringLiteral( "noborderrule" ) );
    }

    /**
      Set Titlebar color and scheme
    */
    void setDecocolor( const QString & v )
    {
      if (!isDecocolorImmutable())
        mDecocolor = v;
    }

    /**
      Get Titlebar color and scheme
    */
    QString decocolor() const
    {
      return mDecocolor;
    }

    /**
      Is Titlebar color and scheme Immutable
    */
    bool isDecocolorImmutable() const
    {
      return isImmutable( QStringLiteral( "decocolor" ) );
    }

    /**
      Set Titlebar color rule type
    */
    void setDecocolorrule( int v )
    {
      if (!isDecocolorruleImmutable())
        mDecocolorrule = v;
    }

    /**
      Get Titlebar color rule type
    */
    int decocolorrule() const
    {
      return mDecocolorrule;
    }

    /**
      Is Titlebar color rule type Immutable
    */
    bool isDecocolorruleImmutable() const
    {
      return isImmutable( QStringLiteral( "decocolorrule" ) );
    }

    /**
      Set Block Compositing
    */
    void setBlockcompositing( bool v )
    {
      if (!isBlockcompositingImmutable())
        mBlockcompositing = v;
    }

    /**
      Get Block Compositing
    */
    bool blockcompositing() const
    {
      return mBlockcompositing;
    }

    /**
      Is Block Compositing Immutable
    */
    bool isBlockcompositingImmutable() const
    {
      return isImmutable( QStringLiteral( "blockcompositing" ) );
    }

    /**
      Set Block Compositing rule type
    */
    void setBlockcompositingrule( int v )
    {
      if (!isBlockcompositingruleImmutable())
        mBlockcompositingrule = v;
    }

    /**
      Get Block Compositing rule type
    */
    int blockcompositingrule() const
    {
      return mBlockcompositingrule;
    }

    /**
      Is Block Compositing rule type Immutable
    */
    bool isBlockcompositingruleImmutable() const
    {
      return isImmutable( QStringLiteral( "blockcompositingrule" ) );
    }

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

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

      if (!isFsplevelImmutable())
        mFsplevel = v;
    }

    /**
      Get Focus stealing prevention
    */
    int fsplevel() const
    {
      return mFsplevel;
    }

    /**
      Is Focus stealing prevention Immutable
    */
    bool isFsplevelImmutable() const
    {
      return isImmutable( QStringLiteral( "fsplevel" ) );
    }

    /**
      Set Focus stealing prevention rule type
    */
    void setFsplevelrule( int v )
    {
      if (!isFsplevelruleImmutable())
        mFsplevelrule = v;
    }

    /**
      Get Focus stealing prevention rule type
    */
    int fsplevelrule() const
    {
      return mFsplevelrule;
    }

    /**
      Is Focus stealing prevention rule type Immutable
    */
    bool isFsplevelruleImmutable() const
    {
      return isImmutable( QStringLiteral( "fsplevelrule" ) );
    }

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

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

      if (!isFpplevelImmutable())
        mFpplevel = v;
    }

    /**
      Get Focus protection
    */
    int fpplevel() const
    {
      return mFpplevel;
    }

    /**
      Is Focus protection Immutable
    */
    bool isFpplevelImmutable() const
    {
      return isImmutable( QStringLiteral( "fpplevel" ) );
    }

    /**
      Set Focus protection rule type
    */
    void setFpplevelrule( int v )
    {
      if (!isFpplevelruleImmutable())
        mFpplevelrule = v;
    }

    /**
      Get Focus protection rule type
    */
    int fpplevelrule() const
    {
      return mFpplevelrule;
    }

    /**
      Is Focus protection rule type Immutable
    */
    bool isFpplevelruleImmutable() const
    {
      return isImmutable( QStringLiteral( "fpplevelrule" ) );
    }

    /**
      Set Accept Focus
    */
    void setAcceptfocus( bool v )
    {
      if (!isAcceptfocusImmutable())
        mAcceptfocus = v;
    }

    /**
      Get Accept Focus
    */
    bool acceptfocus() const
    {
      return mAcceptfocus;
    }

    /**
      Is Accept Focus Immutable
    */
    bool isAcceptfocusImmutable() const
    {
      return isImmutable( QStringLiteral( "acceptfocus" ) );
    }

    /**
      Set Accept Focus rule type
    */
    void setAcceptfocusrule( int v )
    {
      if (!isAcceptfocusruleImmutable())
        mAcceptfocusrule = v;
    }

    /**
      Get Accept Focus rule type
    */
    int acceptfocusrule() const
    {
      return mAcceptfocusrule;
    }

    /**
      Is Accept Focus rule type Immutable
    */
    bool isAcceptfocusruleImmutable() const
    {
      return isImmutable( QStringLiteral( "acceptfocusrule" ) );
    }

    /**
      Set Closeable
    */
    void setCloseable( bool v )
    {
      if (!isCloseableImmutable())
        mCloseable = v;
    }

    /**
      Get Closeable
    */
    bool closeable() const
    {
      return mCloseable;
    }

    /**
      Is Closeable Immutable
    */
    bool isCloseableImmutable() const
    {
      return isImmutable( QStringLiteral( "closeable" ) );
    }

    /**
      Set Closeable rule type
    */
    void setCloseablerule( int v )
    {
      if (!isCloseableruleImmutable())
        mCloseablerule = v;
    }

    /**
      Get Closeable rule type
    */
    int closeablerule() const
    {
      return mCloseablerule;
    }

    /**
      Is Closeable rule type Immutable
    */
    bool isCloseableruleImmutable() const
    {
      return isImmutable( QStringLiteral( "closeablerule" ) );
    }

    /**
      Set Autogroup with identical
    */
    void setAutogroup( bool v )
    {
      if (!isAutogroupImmutable())
        mAutogroup = v;
    }

    /**
      Get Autogroup with identical
    */
    bool autogroup() const
    {
      return mAutogroup;
    }

    /**
      Is Autogroup with identical Immutable
    */
    bool isAutogroupImmutable() const
    {
      return isImmutable( QStringLiteral( "autogroup" ) );
    }

    /**
      Set Autogroup with identical rule type
    */
    void setAutogrouprule( int v )
    {
      if (!isAutogroupruleImmutable())
        mAutogrouprule = v;
    }

    /**
      Get Autogroup with identical rule type
    */
    int autogrouprule() const
    {
      return mAutogrouprule;
    }

    /**
      Is Autogroup with identical rule type Immutable
    */
    bool isAutogroupruleImmutable() const
    {
      return isImmutable( QStringLiteral( "autogrouprule" ) );
    }

    /**
      Set Autogroup in foreground
    */
    void setAutogroupfg( bool v )
    {
      if (!isAutogroupfgImmutable())
        mAutogroupfg = v;
    }

    /**
      Get Autogroup in foreground
    */
    bool autogroupfg() const
    {
      return mAutogroupfg;
    }

    /**
      Is Autogroup in foreground Immutable
    */
    bool isAutogroupfgImmutable() const
    {
      return isImmutable( QStringLiteral( "autogroupfg" ) );
    }

    /**
      Set Autogroup in foreground rule type
    */
    void setAutogroupfgrule( int v )
    {
      if (!isAutogroupfgruleImmutable())
        mAutogroupfgrule = v;
    }

    /**
      Get Autogroup in foreground rule type
    */
    int autogroupfgrule() const
    {
      return mAutogroupfgrule;
    }

    /**
      Is Autogroup in foreground rule type Immutable
    */
    bool isAutogroupfgruleImmutable() const
    {
      return isImmutable( QStringLiteral( "autogroupfgrule" ) );
    }

    /**
      Set Autogroup by ID
    */
    void setAutogroupid( const QString & v )
    {
      if (!isAutogroupidImmutable())
        mAutogroupid = v;
    }

    /**
      Get Autogroup by ID
    */
    QString autogroupid() const
    {
      return mAutogroupid;
    }

    /**
      Is Autogroup by ID Immutable
    */
    bool isAutogroupidImmutable() const
    {
      return isImmutable( QStringLiteral( "autogroupid" ) );
    }

    /**
      Set Autogroup by ID rule type
    */
    void setAutogroupidrule( int v )
    {
      if (!isAutogroupidruleImmutable())
        mAutogroupidrule = v;
    }

    /**
      Get Autogroup by ID rule type
    */
    int autogroupidrule() const
    {
      return mAutogroupidrule;
    }

    /**
      Is Autogroup by ID rule type Immutable
    */
    bool isAutogroupidruleImmutable() const
    {
      return isImmutable( QStringLiteral( "autogroupidrule" ) );
    }

    /**
      Set Obey geometry restrictions
    */
    void setStrictgeometry( bool v )
    {
      if (!isStrictgeometryImmutable())
        mStrictgeometry = v;
    }

    /**
      Get Obey geometry restrictions
    */
    bool strictgeometry() const
    {
      return mStrictgeometry;
    }

    /**
      Is Obey geometry restrictions Immutable
    */
    bool isStrictgeometryImmutable() const
    {
      return isImmutable( QStringLiteral( "strictgeometry" ) );
    }

    /**
      Set Obey geometry restrictions rule type
    */
    void setStrictgeometryrule( int v )
    {
      if (!isStrictgeometryruleImmutable())
        mStrictgeometryrule = v;
    }

    /**
      Get Obey geometry restrictions rule type
    */
    int strictgeometryrule() const
    {
      return mStrictgeometryrule;
    }

    /**
      Is Obey geometry restrictions rule type Immutable
    */
    bool isStrictgeometryruleImmutable() const
    {
      return isImmutable( QStringLiteral( "strictgeometryrule" ) );
    }

    /**
      Set Shortcut
    */
    void setShortcut( const QString & v )
    {
      if (!isShortcutImmutable())
        mShortcut = v;
    }

    /**
      Get Shortcut
    */
    QString shortcut() const
    {
      return mShortcut;
    }

    /**
      Is Shortcut Immutable
    */
    bool isShortcutImmutable() const
    {
      return isImmutable( QStringLiteral( "shortcut" ) );
    }

    /**
      Set Shortcut rule type
    */
    void setShortcutrule( int v )
    {
      if (v < Rules::UnusedSetRule)
      {
        qDebug() << "setShortcutrule: value " << v << " is less than the minimum value of Rules::UnusedSetRule";
        v = Rules::UnusedSetRule;
      }

      if (v > static_cast<Rules::SetRule>(Rules::ForceTemporarily))
      {
        qDebug() << "setShortcutrule: value " << v << " is greater than the maximum value of static_cast<Rules::SetRule>(Rules::ForceTemporarily)";
        v = static_cast<Rules::SetRule>(Rules::ForceTemporarily);
      }

      if (!isShortcutruleImmutable())
        mShortcutrule = v;
    }

    /**
      Get Shortcut rule type
    */
    int shortcutrule() const
    {
      return mShortcutrule;
    }

    /**
      Is Shortcut rule type Immutable
    */
    bool isShortcutruleImmutable() const
    {
      return isImmutable( QStringLiteral( "shortcutrule" ) );
    }

    /**
      Set Ignore global shortcuts
    */
    void setDisableglobalshortcuts( bool v )
    {
      if (!isDisableglobalshortcutsImmutable())
        mDisableglobalshortcuts = v;
    }

    /**
      Get Ignore global shortcuts
    */
    bool disableglobalshortcuts() const
    {
      return mDisableglobalshortcuts;
    }

    /**
      Is Ignore global shortcuts Immutable
    */
    bool isDisableglobalshortcutsImmutable() const
    {
      return isImmutable( QStringLiteral( "disableglobalshortcuts" ) );
    }

    /**
      Set Ignore global shortcuts rule type
    */
    void setDisableglobalshortcutsrule( int v )
    {
      if (!isDisableglobalshortcutsruleImmutable())
        mDisableglobalshortcutsrule = v;
    }

    /**
      Get Ignore global shortcuts rule type
    */
    int disableglobalshortcutsrule() const
    {
      return mDisableglobalshortcutsrule;
    }

    /**
      Is Ignore global shortcuts rule type Immutable
    */
    bool isDisableglobalshortcutsruleImmutable() const
    {
      return isImmutable( QStringLiteral( "disableglobalshortcutsrule" ) );
    }

    /**
      Set Desktop file name
    */
    void setDesktopfile( const QString & v )
    {
      if (!isDesktopfileImmutable())
        mDesktopfile = v;
    }

    /**
      Get Desktop file name
    */
    QString desktopfile() const
    {
      return mDesktopfile;
    }

    /**
      Is Desktop file name Immutable
    */
    bool isDesktopfileImmutable() const
    {
      return isImmutable( QStringLiteral( "desktopfile" ) );
    }

    /**
      Set Desktop file name rule type
    */
    void setDesktopfilerule( int v )
    {
      if (v < Rules::UnusedSetRule)
      {
        qDebug() << "setDesktopfilerule: value " << v << " is less than the minimum value of Rules::UnusedSetRule";
        v = Rules::UnusedSetRule;
      }

      if (v > static_cast<Rules::SetRule>(Rules::ForceTemporarily))
      {
        qDebug() << "setDesktopfilerule: value " << v << " is greater than the maximum value of static_cast<Rules::SetRule>(Rules::ForceTemporarily)";
        v = static_cast<Rules::SetRule>(Rules::ForceTemporarily);
      }

      if (!isDesktopfileruleImmutable())
        mDesktopfilerule = v;
    }

    /**
      Get Desktop file name rule type
    */
    int desktopfilerule() const
    {
      return mDesktopfilerule;
    }

    /**
      Is Desktop file name rule type Immutable
    */
    bool isDesktopfileruleImmutable() const
    {
      return isImmutable( QStringLiteral( "desktopfilerule" ) );
    }

    /**
      Set Layer
    */
    void setLayer( KWin::Layer v )
    {
      if (!isLayerImmutable())
        mLayer = int(v);
    }

    /**
      Get Layer
    */
    KWin::Layer layer() const
    {
      return static_cast<KWin::Layer>(mLayer);
    }

    /**
      Is Layer Immutable
    */
    bool isLayerImmutable() const
    {
      return isImmutable( QStringLiteral( "layer" ) );
    }

    /**
      Set Layer rule type
    */
    void setLayerrule( int v )
    {
      if (!isLayerruleImmutable())
        mLayerrule = v;
    }

    /**
      Get Layer rule type
    */
    int layerrule() const
    {
      return mLayerrule;
    }

    /**
      Is Layer rule type Immutable
    */
    bool isLayerruleImmutable() const
    {
      return isImmutable( QStringLiteral( "layerrule" ) );
    }

    /**
      Set AdaptiveSync
    */
    void setAdaptivesync( bool v )
    {
      if (!isAdaptivesyncImmutable())
        mAdaptivesync = v;
    }

    /**
      Get AdaptiveSync
    */
    bool adaptivesync() const
    {
      return mAdaptivesync;
    }

    /**
      Is AdaptiveSync Immutable
    */
    bool isAdaptivesyncImmutable() const
    {
      return isImmutable( QStringLiteral( "adaptivesync" ) );
    }

    /**
      Set AdaptiveSync rule type
    */
    void setAdaptivesyncrule( int v )
    {
      if (!isAdaptivesyncruleImmutable())
        mAdaptivesyncrule = v;
    }

    /**
      Get AdaptiveSync rule type
    */
    int adaptivesyncrule() const
    {
      return mAdaptivesyncrule;
    }

    /**
      Is AdaptiveSync rule type Immutable
    */
    bool isAdaptivesyncruleImmutable() const
    {
      return isImmutable( QStringLiteral( "adaptivesyncrule" ) );
    }

    /**
      Set Allow Tearing
    */
    void setTearing( bool v )
    {
      if (!isTearingImmutable())
        mTearing = v;
    }

    /**
      Get Allow Tearing
    */
    bool tearing() const
    {
      return mTearing;
    }

    /**
      Is Allow Tearing Immutable
    */
    bool isTearingImmutable() const
    {
      return isImmutable( QStringLiteral( "tearing" ) );
    }

    /**
      Set Tearing rule type
    */
    void setTearingrule( int v )
    {
      if (!isTearingruleImmutable())
        mTearingrule = v;
    }

    /**
      Get Tearing rule type
    */
    int tearingrule() const
    {
      return mTearingrule;
    }

    /**
      Is Tearing rule type Immutable
    */
    bool isTearingruleImmutable() const
    {
      return isImmutable( QStringLiteral( "tearingrule" ) );
    }

    /**
      Set Hide from screenshots and screen recordings
    */
    void setExcludefromcapture( bool v )
    {
      if (!isExcludefromcaptureImmutable())
        mExcludefromcapture = v;
    }

    /**
      Get Hide from screenshots and screen recordings
    */
    bool excludefromcapture() const
    {
      return mExcludefromcapture;
    }

    /**
      Is Hide from screenshots and screen recordings Immutable
    */
    bool isExcludefromcaptureImmutable() const
    {
      return isImmutable( QStringLiteral( "excludefromcapture" ) );
    }

    /**
      Set Hide from screenshots and screen recordings rule type
    */
    void setExcludefromcapturerule( int v )
    {
      if (v < Rules::UnusedSetRule)
      {
        qDebug() << "setExcludefromcapturerule: value " << v << " is less than the minimum value of Rules::UnusedSetRule";
        v = Rules::UnusedSetRule;
      }

      if (v > static_cast<Rules::SetRule>(Rules::ForceTemporarily))
      {
        qDebug() << "setExcludefromcapturerule: value " << v << " is greater than the maximum value of static_cast<Rules::SetRule>(Rules::ForceTemporarily)";
        v = static_cast<Rules::SetRule>(Rules::ForceTemporarily);
      }

      if (!isExcludefromcaptureruleImmutable())
        mExcludefromcapturerule = v;
    }

    /**
      Get Hide from screenshots and screen recordings rule type
    */
    int excludefromcapturerule() const
    {
      return mExcludefromcapturerule;
    }

    /**
      Is Hide from screenshots and screen recordings rule type Immutable
    */
    bool isExcludefromcaptureruleImmutable() const
    {
      return isImmutable( QStringLiteral( "excludefromcapturerule" ) );
    }

  protected:
    QString mParamruleDescriptionOrNumber;

    // $(ruleDescriptionOrNumber)
    QString mDescription;
    QString mDescriptionLegacy;
    bool mDeleteRule;
    bool mEnabled;
    QString mWmclass;
    int mWmclassmatch;
    bool mWmclasscomplete;
    QString mWindowrole;
    int mWindowrolematch;
    QString mTitle;
    int mTitlematch;
    QString mClientmachine;
    int mClientmachinematch;
    QString mTag;
    int mTagmatch;
    bool mHastransientparent;
    int mHastransientparentmatch;
    uint mTypes;
    int mPlacement;
    int mPlacementrule;
    QPoint mPosition;
    int mPositionrule;
    QSize mSize;
    int mSizerule;
    QSize mMinsize;
    int mMinsizerule;
    QSize mMaxsize;
    int mMaxsizerule;
    int mOpacityactive;
    int mOpacityactiverule;
    int mOpacityinactive;
    int mOpacityinactiverule;
    bool mIgnoregeometry;
    int mIgnoregeometryrule;
    QStringList mDesktops;
    int mDesktopsrule;
    int mScreen;
    int mScreenrule;
    QStringList mActivity;
    int mActivityrule;
    bool mMaximizevert;
    int mMaximizevertrule;
    bool mMaximizehoriz;
    int mMaximizehorizrule;
    bool mMinimize;
    int mMinimizerule;
    bool mSkiptaskbar;
    int mSkiptaskbarrule;
    bool mSkippager;
    int mSkippagerrule;
    bool mSkipswitcher;
    int mSkipswitcherrule;
    bool mAbove;
    int mAboverule;
    bool mBelow;
    int mBelowrule;
    bool mFullscreen;
    int mFullscreenrule;
    bool mNoborder;
    int mNoborderrule;
    QString mDecocolor;
    int mDecocolorrule;
    bool mBlockcompositing;
    int mBlockcompositingrule;
    int mFsplevel;
    int mFsplevelrule;
    int mFpplevel;
    int mFpplevelrule;
    bool mAcceptfocus;
    int mAcceptfocusrule;
    bool mCloseable;
    int mCloseablerule;
    bool mAutogroup;
    int mAutogrouprule;
    bool mAutogroupfg;
    int mAutogroupfgrule;
    QString mAutogroupid;
    int mAutogroupidrule;
    bool mStrictgeometry;
    int mStrictgeometryrule;
    QString mShortcut;
    int mShortcutrule;
    bool mDisableglobalshortcuts;
    int mDisableglobalshortcutsrule;
    QString mDesktopfile;
    int mDesktopfilerule;
    int mLayer;
    int mLayerrule;
    bool mAdaptivesync;
    int mAdaptivesyncrule;
    bool mTearing;
    int mTearingrule;
    bool mExcludefromcapture;
    int mExcludefromcapturerule;
};

}

#endif

