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

#include <kptconfigskeleton.h>

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

class PLAN_EXPORT KPlatoSettings : public KPlatoConfigSkeleton
{
  public:
    class EnumGenerateWeekChoice
    {
      public:
      enum type { NoneExists, Always, COUNT };
    };
    class EnumGenerateHolidaysChoice
    {
      public:
      enum type { InWeekCalendar, AsSubCalendar, AsSeparateCalendar, COUNT };
    };
    class EnumConstraintType
    {
      public:
      enum type { AsSoonAsPossible, AsLateAsPossible, MustStartOn, MustFinishOn, StartNotEarlierThan, FinishNotLaterThan, FixedInterval, COUNT };
    };
    class EnumStartTimeUsage
    {
      public:
      enum type { CurrentdateTime, CurrentDate, SpecifiedDateTime, COUNT };
    };
    class EnumEndTimeUsage
    {
      public:
      enum type { CurrentdateTime, CurrentDate, SpecifiedDateTime, COUNT };
    };
    class EnumEstimateType
    {
      public:
      enum type { Effort, Duration, COUNT };
    };
    class EnumUnit
    {
      public:
      enum type { Year, Month, Week, Day, Hour, Minute, Second, Millisecond, COUNT };
    };
    class EnumRisk
    {
      public:
      enum type { None, Low, High, COUNT };
    };
    class EnumColorGradientType
    {
      public:
      enum type { Linear, Flat, COUNT };
    };

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

    /**
      Set Hours per year
    */
    static
    void setHoursPrYear( double v )
    {
      if (!self()->isHoursPrYearImmutable())
        self()->mHoursPrYear = v;
    }

    /**
      Get Hours per year
    */
    static
    double hoursPrYear()
    {
      return self()->mHoursPrYear;
    }

    /**
      Is Hours per year Immutable
    */
    static
    bool isHoursPrYearImmutable()
    {
      return self()->isImmutable( QStringLiteral( "HoursPrYear" ) );
    }

    /**
      Set Hours per month
    */
    static
    void setHoursPrMonth( double v )
    {
      if (!self()->isHoursPrMonthImmutable())
        self()->mHoursPrMonth = v;
    }

    /**
      Get Hours per month
    */
    static
    double hoursPrMonth()
    {
      return self()->mHoursPrMonth;
    }

    /**
      Is Hours per month Immutable
    */
    static
    bool isHoursPrMonthImmutable()
    {
      return self()->isImmutable( QStringLiteral( "HoursPrMonth" ) );
    }

    /**
      Set Hours per week
    */
    static
    void setHoursPrWeek( double v )
    {
      if (!self()->isHoursPrWeekImmutable())
        self()->mHoursPrWeek = v;
    }

    /**
      Get Hours per week
    */
    static
    double hoursPrWeek()
    {
      return self()->mHoursPrWeek;
    }

    /**
      Is Hours per week Immutable
    */
    static
    bool isHoursPrWeekImmutable()
    {
      return self()->isImmutable( QStringLiteral( "HoursPrWeek" ) );
    }

    /**
      Set Hours per day
    */
    static
    void setHoursPrDay( double v )
    {
      if (!self()->isHoursPrDayImmutable())
        self()->mHoursPrDay = v;
    }

    /**
      Get Hours per day
    */
    static
    double hoursPrDay()
    {
      return self()->mHoursPrDay;
    }

    /**
      Is Hours per day Immutable
    */
    static
    bool isHoursPrDayImmutable()
    {
      return self()->isImmutable( QStringLiteral( "HoursPrDay" ) );
    }

    /**
      Set Generate working week
    */
    static
    void setGenerateWeek( bool v )
    {
      if (!self()->isGenerateWeekImmutable())
        self()->mGenerateWeek = v;
    }

    /**
      Get Generate working week
    */
    static
    bool generateWeek()
    {
      return self()->mGenerateWeek;
    }

    /**
      Is Generate working week Immutable
    */
    static
    bool isGenerateWeekImmutable()
    {
      return self()->isImmutable( QStringLiteral( "GenerateWeek" ) );
    }

    /**
      Set Generate working week options
    */
    static
    void setGenerateWeekChoice( int v )
    {
      if (!self()->isGenerateWeekChoiceImmutable())
        self()->mGenerateWeekChoice = v;
    }

    /**
      Get Generate working week options
    */
    static
    int generateWeekChoice()
    {
      return self()->mGenerateWeekChoice;
    }

    /**
      Is Generate working week options Immutable
    */
    static
    bool isGenerateWeekChoiceImmutable()
    {
      return self()->isImmutable( QStringLiteral( "GenerateWeekChoice" ) );
    }

    /**
      Set Generate holidays
    */
    static
    void setGenerateHolidays( bool v )
    {
      if (!self()->isGenerateHolidaysImmutable())
        self()->mGenerateHolidays = v;
    }

    /**
      Get Generate holidays
    */
    static
    bool generateHolidays()
    {
      return self()->mGenerateHolidays;
    }

    /**
      Is Generate holidays Immutable
    */
    static
    bool isGenerateHolidaysImmutable()
    {
      return self()->isImmutable( QStringLiteral( "GenerateHolidays" ) );
    }

    /**
      Set Generate holidays options
    */
    static
    void setGenerateHolidaysChoice( int v )
    {
      if (!self()->isGenerateHolidaysChoiceImmutable())
        self()->mGenerateHolidaysChoice = v;
    }

    /**
      Get Generate holidays options
    */
    static
    int generateHolidaysChoice()
    {
      return self()->mGenerateHolidaysChoice;
    }

    /**
      Is Generate holidays options Immutable
    */
    static
    bool isGenerateHolidaysChoiceImmutable()
    {
      return self()->isImmutable( QStringLiteral( "GenerateHolidaysChoice" ) );
    }

    /**
      Set Holiday region
    */
    static
    void setRegion( const QString & v )
    {
      if (!self()->isRegionImmutable())
        self()->mRegion = v;
    }

    /**
      Get Holiday region
    */
    static
    QString region()
    {
      return self()->mRegion;
    }

    /**
      Is Holiday region Immutable
    */
    static
    bool isRegionImmutable()
    {
      return self()->isImmutable( QStringLiteral( "Region" ) );
    }

    /**
      Set Monday:
    */
    static
    void setMonday( bool v )
    {
      if (!self()->isMondayImmutable())
        self()->mMonday = v;
    }

    /**
      Get Monday:
    */
    static
    bool monday()
    {
      return self()->mMonday;
    }

    /**
      Is Monday: Immutable
    */
    static
    bool isMondayImmutable()
    {
      return self()->isImmutable( QStringLiteral( "Monday" ) );
    }

    /**
      Set Start of working day
    */
    static
    void setMondayStart( const QString & v )
    {
      if (!self()->isMondayStartImmutable())
        self()->mMondayStart = v;
    }

    /**
      Get Start of working day
    */
    static
    QString mondayStart()
    {
      return self()->mMondayStart;
    }

    /**
      Is Start of working day Immutable
    */
    static
    bool isMondayStartImmutable()
    {
      return self()->isImmutable( QStringLiteral( "MondayStart" ) );
    }

    /**
      Set End of working day
    */
    static
    void setMondayEnd( const QString & v )
    {
      if (!self()->isMondayEndImmutable())
        self()->mMondayEnd = v;
    }

    /**
      Get End of working day
    */
    static
    QString mondayEnd()
    {
      return self()->mMondayEnd;
    }

    /**
      Is End of working day Immutable
    */
    static
    bool isMondayEndImmutable()
    {
      return self()->isImmutable( QStringLiteral( "MondayEnd" ) );
    }

    /**
      Set Tuesday:
    */
    static
    void setTuesday( bool v )
    {
      if (!self()->isTuesdayImmutable())
        self()->mTuesday = v;
    }

    /**
      Get Tuesday:
    */
    static
    bool tuesday()
    {
      return self()->mTuesday;
    }

    /**
      Is Tuesday: Immutable
    */
    static
    bool isTuesdayImmutable()
    {
      return self()->isImmutable( QStringLiteral( "Tuesday" ) );
    }

    /**
      Set Start of working day
    */
    static
    void setTuesdayStart( const QString & v )
    {
      if (!self()->isTuesdayStartImmutable())
        self()->mTuesdayStart = v;
    }

    /**
      Get Start of working day
    */
    static
    QString tuesdayStart()
    {
      return self()->mTuesdayStart;
    }

    /**
      Is Start of working day Immutable
    */
    static
    bool isTuesdayStartImmutable()
    {
      return self()->isImmutable( QStringLiteral( "TuesdayStart" ) );
    }

    /**
      Set End of working day
    */
    static
    void setTuesdayEnd( const QString & v )
    {
      if (!self()->isTuesdayEndImmutable())
        self()->mTuesdayEnd = v;
    }

    /**
      Get End of working day
    */
    static
    QString tuesdayEnd()
    {
      return self()->mTuesdayEnd;
    }

    /**
      Is End of working day Immutable
    */
    static
    bool isTuesdayEndImmutable()
    {
      return self()->isImmutable( QStringLiteral( "TuesdayEnd" ) );
    }

    /**
      Set Wednesday:
    */
    static
    void setWednesday( bool v )
    {
      if (!self()->isWednesdayImmutable())
        self()->mWednesday = v;
    }

    /**
      Get Wednesday:
    */
    static
    bool wednesday()
    {
      return self()->mWednesday;
    }

    /**
      Is Wednesday: Immutable
    */
    static
    bool isWednesdayImmutable()
    {
      return self()->isImmutable( QStringLiteral( "Wednesday" ) );
    }

    /**
      Set Start of working day
    */
    static
    void setWednesdayStart( const QString & v )
    {
      if (!self()->isWednesdayStartImmutable())
        self()->mWednesdayStart = v;
    }

    /**
      Get Start of working day
    */
    static
    QString wednesdayStart()
    {
      return self()->mWednesdayStart;
    }

    /**
      Is Start of working day Immutable
    */
    static
    bool isWednesdayStartImmutable()
    {
      return self()->isImmutable( QStringLiteral( "WednesdayStart" ) );
    }

    /**
      Set End of working day
    */
    static
    void setWednesdayEnd( const QString & v )
    {
      if (!self()->isWednesdayEndImmutable())
        self()->mWednesdayEnd = v;
    }

    /**
      Get End of working day
    */
    static
    QString wednesdayEnd()
    {
      return self()->mWednesdayEnd;
    }

    /**
      Is End of working day Immutable
    */
    static
    bool isWednesdayEndImmutable()
    {
      return self()->isImmutable( QStringLiteral( "WednesdayEnd" ) );
    }

    /**
      Set Thursday:
    */
    static
    void setThursday( bool v )
    {
      if (!self()->isThursdayImmutable())
        self()->mThursday = v;
    }

    /**
      Get Thursday:
    */
    static
    bool thursday()
    {
      return self()->mThursday;
    }

    /**
      Is Thursday: Immutable
    */
    static
    bool isThursdayImmutable()
    {
      return self()->isImmutable( QStringLiteral( "Thursday" ) );
    }

    /**
      Set Start of working day
    */
    static
    void setThursdayStart( const QString & v )
    {
      if (!self()->isThursdayStartImmutable())
        self()->mThursdayStart = v;
    }

    /**
      Get Start of working day
    */
    static
    QString thursdayStart()
    {
      return self()->mThursdayStart;
    }

    /**
      Is Start of working day Immutable
    */
    static
    bool isThursdayStartImmutable()
    {
      return self()->isImmutable( QStringLiteral( "ThursdayStart" ) );
    }

    /**
      Set End of working day
    */
    static
    void setThursdayEnd( const QString & v )
    {
      if (!self()->isThursdayEndImmutable())
        self()->mThursdayEnd = v;
    }

    /**
      Get End of working day
    */
    static
    QString thursdayEnd()
    {
      return self()->mThursdayEnd;
    }

    /**
      Is End of working day Immutable
    */
    static
    bool isThursdayEndImmutable()
    {
      return self()->isImmutable( QStringLiteral( "ThursdayEnd" ) );
    }

    /**
      Set Friday:
    */
    static
    void setFriday( bool v )
    {
      if (!self()->isFridayImmutable())
        self()->mFriday = v;
    }

    /**
      Get Friday:
    */
    static
    bool friday()
    {
      return self()->mFriday;
    }

    /**
      Is Friday: Immutable
    */
    static
    bool isFridayImmutable()
    {
      return self()->isImmutable( QStringLiteral( "Friday" ) );
    }

    /**
      Set Start of working day
    */
    static
    void setFridayStart( const QString & v )
    {
      if (!self()->isFridayStartImmutable())
        self()->mFridayStart = v;
    }

    /**
      Get Start of working day
    */
    static
    QString fridayStart()
    {
      return self()->mFridayStart;
    }

    /**
      Is Start of working day Immutable
    */
    static
    bool isFridayStartImmutable()
    {
      return self()->isImmutable( QStringLiteral( "FridayStart" ) );
    }

    /**
      Set End of working day
    */
    static
    void setFridayEnd( const QString & v )
    {
      if (!self()->isFridayEndImmutable())
        self()->mFridayEnd = v;
    }

    /**
      Get End of working day
    */
    static
    QString fridayEnd()
    {
      return self()->mFridayEnd;
    }

    /**
      Is End of working day Immutable
    */
    static
    bool isFridayEndImmutable()
    {
      return self()->isImmutable( QStringLiteral( "FridayEnd" ) );
    }

    /**
      Set Saturday:
    */
    static
    void setSaturday( bool v )
    {
      if (!self()->isSaturdayImmutable())
        self()->mSaturday = v;
    }

    /**
      Get Saturday:
    */
    static
    bool saturday()
    {
      return self()->mSaturday;
    }

    /**
      Is Saturday: Immutable
    */
    static
    bool isSaturdayImmutable()
    {
      return self()->isImmutable( QStringLiteral( "Saturday" ) );
    }

    /**
      Set Start of working day
    */
    static
    void setSaturdayStart( const QString & v )
    {
      if (!self()->isSaturdayStartImmutable())
        self()->mSaturdayStart = v;
    }

    /**
      Get Start of working day
    */
    static
    QString saturdayStart()
    {
      return self()->mSaturdayStart;
    }

    /**
      Is Start of working day Immutable
    */
    static
    bool isSaturdayStartImmutable()
    {
      return self()->isImmutable( QStringLiteral( "SaturdayStart" ) );
    }

    /**
      Set End of working day
    */
    static
    void setSaturdayEnd( const QString & v )
    {
      if (!self()->isSaturdayEndImmutable())
        self()->mSaturdayEnd = v;
    }

    /**
      Get End of working day
    */
    static
    QString saturdayEnd()
    {
      return self()->mSaturdayEnd;
    }

    /**
      Is End of working day Immutable
    */
    static
    bool isSaturdayEndImmutable()
    {
      return self()->isImmutable( QStringLiteral( "SaturdayEnd" ) );
    }

    /**
      Set Sunday:
    */
    static
    void setSunday( bool v )
    {
      if (!self()->isSundayImmutable())
        self()->mSunday = v;
    }

    /**
      Get Sunday:
    */
    static
    bool sunday()
    {
      return self()->mSunday;
    }

    /**
      Is Sunday: Immutable
    */
    static
    bool isSundayImmutable()
    {
      return self()->isImmutable( QStringLiteral( "Sunday" ) );
    }

    /**
      Set Start of working day
    */
    static
    void setSundayStart( const QString & v )
    {
      if (!self()->isSundayStartImmutable())
        self()->mSundayStart = v;
    }

    /**
      Get Start of working day
    */
    static
    QString sundayStart()
    {
      return self()->mSundayStart;
    }

    /**
      Is Start of working day Immutable
    */
    static
    bool isSundayStartImmutable()
    {
      return self()->isImmutable( QStringLiteral( "SundayStart" ) );
    }

    /**
      Set End of working day
    */
    static
    void setSundayEnd( const QString & v )
    {
      if (!self()->isSundayEndImmutable())
        self()->mSundayEnd = v;
    }

    /**
      Get End of working day
    */
    static
    QString sundayEnd()
    {
      return self()->mSundayEnd;
    }

    /**
      Is End of working day Immutable
    */
    static
    bool isSundayEndImmutable()
    {
      return self()->isImmutable( QStringLiteral( "SundayEnd" ) );
    }

    /**
      Set Name of project manager
    */
    static
    void setManager( const QString & v )
    {
      if (!self()->isManagerImmutable())
        self()->mManager = v;
    }

    /**
      Get Name of project manager
    */
    static
    QString manager()
    {
      return self()->mManager;
    }

    /**
      Is Name of project manager Immutable
    */
    static
    bool isManagerImmutable()
    {
      return self()->isImmutable( QStringLiteral( "Manager" ) );
    }

    /**
      Set Use shared resources
    */
    static
    void setUseSharedResources( bool v )
    {
      if (!self()->isUseSharedResourcesImmutable())
        self()->mUseSharedResources = v;
    }

    /**
      Get Use shared resources
    */
    static
    bool useSharedResources()
    {
      return self()->mUseSharedResources;
    }

    /**
      Is Use shared resources Immutable
    */
    static
    bool isUseSharedResourcesImmutable()
    {
      return self()->isImmutable( QStringLiteral( "UseSharedResources" ) );
    }

    /**
      Set File to contain shared resources
    */
    static
    void setSharedResourcesFile( const QString & v )
    {
      if (!self()->isSharedResourcesFileImmutable())
        self()->mSharedResourcesFile = v;
    }

    /**
      Get File to contain shared resources
    */
    static
    QString sharedResourcesFile()
    {
      return self()->mSharedResourcesFile;
    }

    /**
      Is File to contain shared resources Immutable
    */
    static
    bool isSharedResourcesFileImmutable()
    {
      return self()->isImmutable( QStringLiteral( "SharedResourcesFile" ) );
    }

    /**
      Set Project description
    */
    static
    void setProjectDescription( const QString & v )
    {
      if (!self()->isProjectDescriptionImmutable())
        self()->mProjectDescription = v;
    }

    /**
      Get Project description
    */
    static
    QString projectDescription()
    {
      return self()->mProjectDescription;
    }

    /**
      Is Project description Immutable
    */
    static
    bool isProjectDescriptionImmutable()
    {
      return self()->isImmutable( QStringLiteral( "ProjectDescription" ) );
    }

    /**
      Set Name of task responsible
    */
    static
    void setLeader( const QString & v )
    {
      if (!self()->isLeaderImmutable())
        self()->mLeader = v;
    }

    /**
      Get Name of task responsible
    */
    static
    QString leader()
    {
      return self()->mLeader;
    }

    /**
      Is Name of task responsible Immutable
    */
    static
    bool isLeaderImmutable()
    {
      return self()->isImmutable( QStringLiteral( "Leader" ) );
    }

    /**
      Set Scheduling constraint type
    */
    static
    void setConstraintType( int v )
    {
      if (!self()->isConstraintTypeImmutable())
        self()->mConstraintType = v;
    }

    /**
      Get Scheduling constraint type
    */
    static
    int constraintType()
    {
      return self()->mConstraintType;
    }

    /**
      Is Scheduling constraint type Immutable
    */
    static
    bool isConstraintTypeImmutable()
    {
      return self()->isImmutable( QStringLiteral( "ConstraintType" ) );
    }

    /**
      Set Defines how start constraint time is used
    */
    static
    void setStartTimeUsage( int v )
    {
      if (!self()->isStartTimeUsageImmutable())
        self()->mStartTimeUsage = v;
    }

    /**
      Get Defines how start constraint time is used
    */
    static
    int startTimeUsage()
    {
      return self()->mStartTimeUsage;
    }

    /**
      Is Defines how start constraint time is used Immutable
    */
    static
    bool isStartTimeUsageImmutable()
    {
      return self()->isImmutable( QStringLiteral( "StartTimeUsage" ) );
    }

    /**
      Set Constraint start date and time
    */
    static
    void setConstraintStartTime( const QDateTime & v )
    {
      if (!self()->isConstraintStartTimeImmutable())
        self()->mConstraintStartTime = v;
    }

    /**
      Get Constraint start date and time
    */
    static
    QDateTime constraintStartTime()
    {
      return self()->mConstraintStartTime;
    }

    /**
      Is Constraint start date and time Immutable
    */
    static
    bool isConstraintStartTimeImmutable()
    {
      return self()->isImmutable( QStringLiteral( "ConstraintStartTime" ) );
    }

    /**
      Set Defines how end constraint time is used
    */
    static
    void setEndTimeUsage( int v )
    {
      if (!self()->isEndTimeUsageImmutable())
        self()->mEndTimeUsage = v;
    }

    /**
      Get Defines how end constraint time is used
    */
    static
    int endTimeUsage()
    {
      return self()->mEndTimeUsage;
    }

    /**
      Is Defines how end constraint time is used Immutable
    */
    static
    bool isEndTimeUsageImmutable()
    {
      return self()->isImmutable( QStringLiteral( "EndTimeUsage" ) );
    }

    /**
      Set Constraint end date and time
    */
    static
    void setConstraintEndTime( const QDateTime & v )
    {
      if (!self()->isConstraintEndTimeImmutable())
        self()->mConstraintEndTime = v;
    }

    /**
      Get Constraint end date and time
    */
    static
    QDateTime constraintEndTime()
    {
      return self()->mConstraintEndTime;
    }

    /**
      Is Constraint end date and time Immutable
    */
    static
    bool isConstraintEndTimeImmutable()
    {
      return self()->isImmutable( QStringLiteral( "ConstraintEndTime" ) );
    }

    /**
      Set Type of estimate
    */
    static
    void setEstimateType( int v )
    {
      if (!self()->isEstimateTypeImmutable())
        self()->mEstimateType = v;
    }

    /**
      Get Type of estimate
    */
    static
    int estimateType()
    {
      return self()->mEstimateType;
    }

    /**
      Is Type of estimate Immutable
    */
    static
    bool isEstimateTypeImmutable()
    {
      return self()->isImmutable( QStringLiteral( "EstimateType" ) );
    }

    /**
      Set Estimate time unit
    */
    static
    void setUnit( int v )
    {
      if (!self()->isUnitImmutable())
        self()->mUnit = v;
    }

    /**
      Get Estimate time unit
    */
    static
    int unit()
    {
      return self()->mUnit;
    }

    /**
      Is Estimate time unit Immutable
    */
    static
    bool isUnitImmutable()
    {
      return self()->isImmutable( QStringLiteral( "Unit" ) );
    }

    /**
      Set Estimate
    */
    static
    void setExpectedEstimate( double v )
    {
      if (!self()->isExpectedEstimateImmutable())
        self()->mExpectedEstimate = v;
    }

    /**
      Get Estimate
    */
    static
    double expectedEstimate()
    {
      return self()->mExpectedEstimate;
    }

    /**
      Is Estimate Immutable
    */
    static
    bool isExpectedEstimateImmutable()
    {
      return self()->isImmutable( QStringLiteral( "ExpectedEstimate" ) );
    }

    /**
      Set Risk
    */
    static
    void setRisk( int v )
    {
      if (!self()->isRiskImmutable())
        self()->mRisk = v;
    }

    /**
      Get Risk
    */
    static
    int risk()
    {
      return self()->mRisk;
    }

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

    /**
      Set Optimistic estimate
    */
    static
    void setOptimisticRatio( int v )
    {
      if (!self()->isOptimisticRatioImmutable())
        self()->mOptimisticRatio = v;
    }

    /**
      Get Optimistic estimate
    */
    static
    int optimisticRatio()
    {
      return self()->mOptimisticRatio;
    }

    /**
      Is Optimistic estimate Immutable
    */
    static
    bool isOptimisticRatioImmutable()
    {
      return self()->isImmutable( QStringLiteral( "OptimisticRatio" ) );
    }

    /**
      Set Pessimistic estimate
    */
    static
    void setPessimisticRatio( int v )
    {
      if (!self()->isPessimisticRatioImmutable())
        self()->mPessimisticRatio = v;
    }

    /**
      Get Pessimistic estimate
    */
    static
    int pessimisticRatio()
    {
      return self()->mPessimisticRatio;
    }

    /**
      Is Pessimistic estimate Immutable
    */
    static
    bool isPessimisticRatioImmutable()
    {
      return self()->isImmutable( QStringLiteral( "PessimisticRatio" ) );
    }

    /**
      Set Task description
    */
    static
    void setDescription( const QString & v )
    {
      if (!self()->isDescriptionImmutable())
        self()->mDescription = v;
    }

    /**
      Get Task description
    */
    static
    QString description()
    {
      return self()->mDescription;
    }

    /**
      Is Task description Immutable
    */
    static
    bool isDescriptionImmutable()
    {
      return self()->isImmutable( QStringLiteral( "Description" ) );
    }

    /**
      Set Gradient
    */
    static
    void setColorGradientType( int v )
    {
      if (!self()->isColorGradientTypeImmutable())
        self()->mColorGradientType = v;
    }

    /**
      Get Gradient
    */
    static
    int colorGradientType()
    {
      return self()->mColorGradientType;
    }

    /**
      Is Gradient Immutable
    */
    static
    bool isColorGradientTypeImmutable()
    {
      return self()->isImmutable( QStringLiteral( "ColorGradientType" ) );
    }

    /**
      Set Enable summary task level colors
    */
    static
    void setSummaryTaskLevelColorsEnabled( bool v )
    {
      if (!self()->isSummaryTaskLevelColorsEnabledImmutable())
        self()->mSummaryTaskLevelColorsEnabled = v;
    }

    /**
      Get Enable summary task level colors
    */
    static
    bool summaryTaskLevelColorsEnabled()
    {
      return self()->mSummaryTaskLevelColorsEnabled;
    }

    /**
      Is Enable summary task level colors Immutable
    */
    static
    bool isSummaryTaskLevelColorsEnabledImmutable()
    {
      return self()->isImmutable( QStringLiteral( "SummaryTaskLevelColorsEnabled" ) );
    }

    /**
      Set Summary task default color
    */
    static
    void setSummaryTaskDefaultColor( const QColor & v )
    {
      if (!self()->isSummaryTaskDefaultColorImmutable())
        self()->mSummaryTaskDefaultColor = v;
    }

    /**
      Get Summary task default color
    */
    static
    QColor summaryTaskDefaultColor()
    {
      return self()->mSummaryTaskDefaultColor;
    }

    /**
      Is Summary task default color Immutable
    */
    static
    bool isSummaryTaskDefaultColorImmutable()
    {
      return self()->isImmutable( QStringLiteral( "SummaryTaskDefaultColor" ) );
    }

    /**
      Set Summary task color, level 1
    */
    static
    void setSummaryTaskLevelColor_1( const QColor & v )
    {
      if (!self()->isSummaryTaskLevelColor_1Immutable())
        self()->mSummaryTaskLevelColor_1 = v;
    }

    /**
      Get Summary task color, level 1
    */
    static
    QColor summaryTaskLevelColor_1()
    {
      return self()->mSummaryTaskLevelColor_1;
    }

    /**
      Is Summary task color, level 1 Immutable
    */
    static
    bool isSummaryTaskLevelColor_1Immutable()
    {
      return self()->isImmutable( QStringLiteral( "SummaryTaskLevelColor_1" ) );
    }

    /**
      Set Summary task color, level 2
    */
    static
    void setSummaryTaskLevelColor_2( const QColor & v )
    {
      if (!self()->isSummaryTaskLevelColor_2Immutable())
        self()->mSummaryTaskLevelColor_2 = v;
    }

    /**
      Get Summary task color, level 2
    */
    static
    QColor summaryTaskLevelColor_2()
    {
      return self()->mSummaryTaskLevelColor_2;
    }

    /**
      Is Summary task color, level 2 Immutable
    */
    static
    bool isSummaryTaskLevelColor_2Immutable()
    {
      return self()->isImmutable( QStringLiteral( "SummaryTaskLevelColor_2" ) );
    }

    /**
      Set Summary task color, level 3
    */
    static
    void setSummaryTaskLevelColor_3( const QColor & v )
    {
      if (!self()->isSummaryTaskLevelColor_3Immutable())
        self()->mSummaryTaskLevelColor_3 = v;
    }

    /**
      Get Summary task color, level 3
    */
    static
    QColor summaryTaskLevelColor_3()
    {
      return self()->mSummaryTaskLevelColor_3;
    }

    /**
      Is Summary task color, level 3 Immutable
    */
    static
    bool isSummaryTaskLevelColor_3Immutable()
    {
      return self()->isImmutable( QStringLiteral( "SummaryTaskLevelColor_3" ) );
    }

    /**
      Set Summary task color, level 4
    */
    static
    void setSummaryTaskLevelColor_4( const QColor & v )
    {
      if (!self()->isSummaryTaskLevelColor_4Immutable())
        self()->mSummaryTaskLevelColor_4 = v;
    }

    /**
      Get Summary task color, level 4
    */
    static
    QColor summaryTaskLevelColor_4()
    {
      return self()->mSummaryTaskLevelColor_4;
    }

    /**
      Is Summary task color, level 4 Immutable
    */
    static
    bool isSummaryTaskLevelColor_4Immutable()
    {
      return self()->isImmutable( QStringLiteral( "SummaryTaskLevelColor_4" ) );
    }

    /**
      Set Task color in normal state
    */
    static
    void setTaskNormalColor( const QColor & v )
    {
      if (!self()->isTaskNormalColorImmutable())
        self()->mTaskNormalColor = v;
    }

    /**
      Get Task color in normal state
    */
    static
    QColor taskNormalColor()
    {
      return self()->mTaskNormalColor;
    }

    /**
      Is Task color in normal state Immutable
    */
    static
    bool isTaskNormalColorImmutable()
    {
      return self()->isImmutable( QStringLiteral( "TaskNormalColor" ) );
    }

    /**
      Set Task color in critical state
    */
    static
    void setTaskCriticalColor( const QColor & v )
    {
      if (!self()->isTaskCriticalColorImmutable())
        self()->mTaskCriticalColor = v;
    }

    /**
      Get Task color in critical state
    */
    static
    QColor taskCriticalColor()
    {
      return self()->mTaskCriticalColor;
    }

    /**
      Is Task color in critical state Immutable
    */
    static
    bool isTaskCriticalColorImmutable()
    {
      return self()->isImmutable( QStringLiteral( "TaskCriticalColor" ) );
    }

    /**
      Set Task color in finished state
    */
    static
    void setTaskFinishedColor( const QColor & v )
    {
      if (!self()->isTaskFinishedColorImmutable())
        self()->mTaskFinishedColor = v;
    }

    /**
      Get Task color in finished state
    */
    static
    QColor taskFinishedColor()
    {
      return self()->mTaskFinishedColor;
    }

    /**
      Is Task color in finished state Immutable
    */
    static
    bool isTaskFinishedColorImmutable()
    {
      return self()->isImmutable( QStringLiteral( "TaskFinishedColor" ) );
    }

    /**
      Set Task color in error state
    */
    static
    void setTaskErrorColor( const QColor & v )
    {
      if (!self()->isTaskErrorColorImmutable())
        self()->mTaskErrorColor = v;
    }

    /**
      Get Task color in error state
    */
    static
    QColor taskErrorColor()
    {
      return self()->mTaskErrorColor;
    }

    /**
      Is Task color in error state Immutable
    */
    static
    bool isTaskErrorColorImmutable()
    {
      return self()->isImmutable( QStringLiteral( "TaskErrorColor" ) );
    }

    /**
      Set Milestone color in normal state
    */
    static
    void setMilestoneNormalColor( const QColor & v )
    {
      if (!self()->isMilestoneNormalColorImmutable())
        self()->mMilestoneNormalColor = v;
    }

    /**
      Get Milestone color in normal state
    */
    static
    QColor milestoneNormalColor()
    {
      return self()->mMilestoneNormalColor;
    }

    /**
      Is Milestone color in normal state Immutable
    */
    static
    bool isMilestoneNormalColorImmutable()
    {
      return self()->isImmutable( QStringLiteral( "MilestoneNormalColor" ) );
    }

    /**
      Set Milestone color in critical state
    */
    static
    void setMilestoneCriticalColor( const QColor & v )
    {
      if (!self()->isMilestoneCriticalColorImmutable())
        self()->mMilestoneCriticalColor = v;
    }

    /**
      Get Milestone color in critical state
    */
    static
    QColor milestoneCriticalColor()
    {
      return self()->mMilestoneCriticalColor;
    }

    /**
      Is Milestone color in critical state Immutable
    */
    static
    bool isMilestoneCriticalColorImmutable()
    {
      return self()->isImmutable( QStringLiteral( "MilestoneCriticalColor" ) );
    }

    /**
      Set Milestone color in finished state
    */
    static
    void setMilestoneFinishedColor( const QColor & v )
    {
      if (!self()->isMilestoneFinishedColorImmutable())
        self()->mMilestoneFinishedColor = v;
    }

    /**
      Get Milestone color in finished state
    */
    static
    QColor milestoneFinishedColor()
    {
      return self()->mMilestoneFinishedColor;
    }

    /**
      Is Milestone color in finished state Immutable
    */
    static
    bool isMilestoneFinishedColorImmutable()
    {
      return self()->isImmutable( QStringLiteral( "MilestoneFinishedColor" ) );
    }

    /**
      Set Milestone color in error state
    */
    static
    void setMilestoneErrorColor( const QColor & v )
    {
      if (!self()->isMilestoneErrorColorImmutable())
        self()->mMilestoneErrorColor = v;
    }

    /**
      Get Milestone color in error state
    */
    static
    QColor milestoneErrorColor()
    {
      return self()->mMilestoneErrorColor;
    }

    /**
      Is Milestone color in error state Immutable
    */
    static
    bool isMilestoneErrorColorImmutable()
    {
      return self()->isImmutable( QStringLiteral( "MilestoneErrorColor" ) );
    }

    /**
      Set Automatically check for new work packages
    */
    static
    void setCheckForWorkPackages( bool v )
    {
      if (!self()->isCheckForWorkPackagesImmutable())
        self()->mCheckForWorkPackages = v;
    }

    /**
      Get Automatically check for new work packages
    */
    static
    bool checkForWorkPackages()
    {
      return self()->mCheckForWorkPackages;
    }

    /**
      Is Automatically check for new work packages Immutable
    */
    static
    bool isCheckForWorkPackagesImmutable()
    {
      return self()->isImmutable( QStringLiteral( "CheckForWorkPackages" ) );
    }

    /**
      Set RetrieveUrl
    */
    static
    void setRetrieveUrl( const QUrl & v )
    {
      if (!self()->isRetrieveUrlImmutable())
        self()->mRetrieveUrl = v;
    }

    /**
      Get RetrieveUrl
    */
    static
    QUrl retrieveUrl()
    {
      return self()->mRetrieveUrl;
    }

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

    /**
      Set DeleteFile
    */
    static
    void setDeleteFile( bool v )
    {
      if (!self()->isDeleteFileImmutable())
        self()->mDeleteFile = v;
    }

    /**
      Get DeleteFile
    */
    static
    bool deleteFile()
    {
      return self()->mDeleteFile;
    }

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

    /**
      Set SaveFile
    */
    static
    void setSaveFile( bool v )
    {
      if (!self()->isSaveFileImmutable())
        self()->mSaveFile = v;
    }

    /**
      Get SaveFile
    */
    static
    bool saveFile()
    {
      return self()->mSaveFile;
    }

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

    /**
      Set SaveUrl
    */
    static
    void setSaveUrl( const QUrl & v )
    {
      if (!self()->isSaveUrlImmutable())
        self()->mSaveUrl = v;
    }

    /**
      Get SaveUrl
    */
    static
    QUrl saveUrl()
    {
      return self()->mSaveUrl;
    }

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

    /**
      Set PublishUrl
    */
    static
    void setPublishUrl( const QUrl & v )
    {
      if (!self()->isPublishUrlImmutable())
        self()->mPublishUrl = v;
    }

    /**
      Get PublishUrl
    */
    static
    QUrl publishUrl()
    {
      return self()->mPublishUrl;
    }

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

    /**
      Set The smallest duration unit allowed
    */
    static
    void setMinimumDurationUnit( int v )
    {
      if (!self()->isMinimumDurationUnitImmutable())
        self()->mMinimumDurationUnit = v;
    }

    /**
      Get The smallest duration unit allowed
    */
    static
    int minimumDurationUnit()
    {
      return self()->mMinimumDurationUnit;
    }

    /**
      Is The smallest duration unit allowed Immutable
    */
    static
    bool isMinimumDurationUnitImmutable()
    {
      return self()->isImmutable( QStringLiteral( "MinimumDurationUnit" ) );
    }

    /**
      Set The largest duration unit allowed
    */
    static
    void setMaximumDurationUnit( int v )
    {
      if (!self()->isMaximumDurationUnitImmutable())
        self()->mMaximumDurationUnit = v;
    }

    /**
      Get The largest duration unit allowed
    */
    static
    int maximumDurationUnit()
    {
      return self()->mMaximumDurationUnit;
    }

    /**
      Is The largest duration unit allowed Immutable
    */
    static
    bool isMaximumDurationUnitImmutable()
    {
      return self()->isImmutable( QStringLiteral( "MaximumDurationUnit" ) );
    }

    /**
      Set Path to the documentation
    */
    static
    void setDocumentationPath( const QString & v )
    {
      if (!self()->isDocumentationPathImmutable())
        self()->mDocumentationPath = v;
    }

    /**
      Get Path to the documentation
    */
    static
    QString documentationPath()
    {
      return self()->mDocumentationPath;
    }

    /**
      Is Path to the documentation Immutable
    */
    static
    bool isDocumentationPathImmutable()
    {
      return self()->isImmutable( QStringLiteral( "DocumentationPath" ) );
    }

    /**
      Set Path to the context help documentation
    */
    static
    void setContextPath( const QString & v )
    {
      if (!self()->isContextPathImmutable())
        self()->mContextPath = v;
    }

    /**
      Get Path to the context help documentation
    */
    static
    QString contextPath()
    {
      return self()->mContextPath;
    }

    /**
      Is Path to the context help documentation Immutable
    */
    static
    bool isContextPathImmutable()
    {
      return self()->isImmutable( QStringLiteral( "ContextPath" ) );
    }

    /**
      Set The context help documentation must have been translated to the language
    */
    static
    void setContextLanguage( const QString & v )
    {
      if (!self()->isContextLanguageImmutable())
        self()->mContextLanguage = v;
    }

    /**
      Get The context help documentation must have been translated to the language
    */
    static
    QString contextLanguage()
    {
      return self()->mContextLanguage;
    }

    /**
      Is The context help documentation must have been translated to the language Immutable
    */
    static
    bool isContextLanguageImmutable()
    {
      return self()->isImmutable( QStringLiteral( "ContextLanguage" ) );
    }

    /**
      Set Use the task modules from your private store
    */
    static
    void setUseLocalTaskModules( bool v )
    {
      if (!self()->isUseLocalTaskModulesImmutable())
        self()->mUseLocalTaskModules = v;
    }

    /**
      Get Use the task modules from your private store
    */
    static
    bool useLocalTaskModules()
    {
      return self()->mUseLocalTaskModules;
    }

    /**
      Is Use the task modules from your private store Immutable
    */
    static
    bool isUseLocalTaskModulesImmutable()
    {
      return self()->isImmutable( QStringLiteral( "UseLocalTaskModules" ) );
    }

    /**
      Set List of paths to task modules
    */
    static
    void setTaskModulePaths( const QStringList & v )
    {
      if (!self()->isTaskModulePathsImmutable())
        self()->mTaskModulePaths = v;
    }

    /**
      Get List of paths to task modules
    */
    static
    QStringList taskModulePaths()
    {
      return self()->mTaskModulePaths;
    }

    /**
      Is List of paths to task modules Immutable
    */
    static
    bool isTaskModulePathsImmutable()
    {
      return self()->isImmutable( QStringLiteral( "TaskModulePaths" ) );
    }

    /**
      Set List of paths to report templates
    */
    static
    void setReportTemplatePaths( const QStringList & v )
    {
      if (!self()->isReportTemplatePathsImmutable())
        self()->mReportTemplatePaths = v;
    }

    /**
      Get List of paths to report templates
    */
    static
    QStringList reportTemplatePaths()
    {
      return self()->mReportTemplatePaths;
    }

    /**
      Is List of paths to report templates Immutable
    */
    static
    bool isReportTemplatePathsImmutable()
    {
      return self()->isImmutable( QStringLiteral( "ReportTemplatePaths" ) );
    }

    /**
      Set List of paths to project templates
    */
    static
    void setProjectTemplatePaths( const QStringList & v )
    {
      if (!self()->isProjectTemplatePathsImmutable())
        self()->mProjectTemplatePaths = v;
    }

    /**
      Get List of paths to project templates
    */
    static
    QStringList projectTemplatePaths()
    {
      return self()->mProjectTemplatePaths;
    }

    /**
      Is List of paths to project templates Immutable
    */
    static
    bool isProjectTemplatePathsImmutable()
    {
      return self()->isImmutable( QStringLiteral( "ProjectTemplatePaths" ) );
    }

    /**
      Set Autosave interval
    */
    static
    void setAutoSave( int v )
    {
      if (!self()->isAutoSaveImmutable())
        self()->mAutoSave = v;
    }

    /**
      Get Autosave interval
    */
    static
    int autoSave()
    {
      return self()->mAutoSave;
    }

    /**
      Is Autosave interval Immutable
    */
    static
    bool isAutoSaveImmutable()
    {
      return self()->isImmutable( QStringLiteral( "AutoSave" ) );
    }

    /**
      Set Create a backup file
    */
    static
    void setCreateBackupFile( bool v )
    {
      if (!self()->isCreateBackupFileImmutable())
        self()->mCreateBackupFile = v;
    }

    /**
      Get Create a backup file
    */
    static
    bool createBackupFile()
    {
      return self()->mCreateBackupFile;
    }

    /**
      Is Create a backup file Immutable
    */
    static
    bool isCreateBackupFileImmutable()
    {
      return self()->isImmutable( QStringLiteral( "CreateBackupFile" ) );
    }

  protected:
    KPlatoSettings();
    friend class KPlatoSettingsHelper;


    // EstimateConversion
    double mHoursPrYear;
    double mHoursPrMonth;
    double mHoursPrWeek;
    double mHoursPrDay;

    // CalendarGeneration
    bool mGenerateWeek;
    int mGenerateWeekChoice;
    bool mGenerateHolidays;
    int mGenerateHolidaysChoice;
    QString mRegion;

    // WorkingWeek
    bool mMonday;
    QString mMondayStart;
    QString mMondayEnd;
    bool mTuesday;
    QString mTuesdayStart;
    QString mTuesdayEnd;
    bool mWednesday;
    QString mWednesdayStart;
    QString mWednesdayEnd;
    bool mThursday;
    QString mThursdayStart;
    QString mThursdayEnd;
    bool mFriday;
    QString mFridayStart;
    QString mFridayEnd;
    bool mSaturday;
    QString mSaturdayStart;
    QString mSaturdayEnd;
    bool mSunday;
    QString mSundayStart;
    QString mSundayEnd;

    // Project settings
    QString mManager;
    bool mUseSharedResources;
    QString mSharedResourcesFile;
    QString mProjectDescription;

    // Task defaults
    QString mLeader;
    int mConstraintType;
    int mStartTimeUsage;
    QDateTime mConstraintStartTime;
    int mEndTimeUsage;
    QDateTime mConstraintEndTime;
    int mEstimateType;
    int mUnit;
    double mExpectedEstimate;
    int mRisk;
    int mOptimisticRatio;
    int mPessimisticRatio;
    QString mDescription;

    // TaskColors
    int mColorGradientType;
    bool mSummaryTaskLevelColorsEnabled;
    QColor mSummaryTaskDefaultColor;
    QColor mSummaryTaskLevelColor_1;
    QColor mSummaryTaskLevelColor_2;
    QColor mSummaryTaskLevelColor_3;
    QColor mSummaryTaskLevelColor_4;
    QColor mTaskNormalColor;
    QColor mTaskCriticalColor;
    QColor mTaskFinishedColor;
    QColor mTaskErrorColor;
    QColor mMilestoneNormalColor;
    QColor mMilestoneCriticalColor;
    QColor mMilestoneFinishedColor;
    QColor mMilestoneErrorColor;

    // Work Package
    bool mCheckForWorkPackages;
    QUrl mRetrieveUrl;
    bool mDeleteFile;
    bool mSaveFile;
    QUrl mSaveUrl;
    QUrl mPublishUrl;

    // Miscellaneous
    int mMinimumDurationUnit;
    int mMaximumDurationUnit;

    // Documentation
    QString mDocumentationPath;
    QString mContextPath;
    QString mContextLanguage;

    // Task Modules
    bool mUseLocalTaskModules;
    QStringList mTaskModulePaths;

    // Report Templates
    QStringList mReportTemplatePaths;

    // Project Templates
    QStringList mProjectTemplatePaths;

    // Interface
    int mAutoSave;
    bool mCreateBackupFile;
};

#endif

