koprefs_base.h

Go to the documentation of this file.

// This file is generated by kconfig_compiler from korganizer.kcfg.
// All changes you do to this file will be lost.
#ifndef KOPREFSBASE_H
#define KOPREFSBASE_H

#include <kglobal.h>
#include <kconfigskeleton.h>
#include <kdebug.h>

#include <klocale.h>
class KOPrefsBase : public KConfigSkeleton
{
  public:
    enum EnumDestination { standardDestination, askDestination };
    enum EnumAgendaViewColors { CategoryInsideResourceOutside, ResourceInsideCategoryOutside, CategoryOnly, ResourceOnly };
    enum EnumAgendaViewCalendarDisplay { CalendarsMerged, CalendarsSideBySide, AllCalendarViews };
    enum EnumMonthViewColors { MonthItemCategoryInsideResourceOutside, MonthItemResourceInsideCategoryOutside, MonthItemCategoryOnly, MonthItemResourceOnly };
    enum EnumDefaultTodoAttachMethod { TodoAttachAsk, TodoAttachLink, TodoAttachInlineFull };

    KOPrefsBase( );
    ~KOPrefsBase();

    void setAutoExport( bool v )
    {
      if (!isImmutable( QString::fromLatin1( "AutoExport" ) ))
        mAutoExport = v;
    }

    bool autoExport() const
    {
      return mAutoExport;
    }

    ItemBool *autoExportItem()
    {
      return mAutoExportItem;
    }

    void setAutoExportInterval( int v )
    {
      if (v < 1)
      {
        kDebug() << "setAutoExportInterval: value " << v << " is less than the minimum value of 1";
        v = 1;
      }
      if (!isImmutable( QString::fromLatin1( "AutoExportInterval" ) ))
        mAutoExportInterval = v;
    }

    int autoExportInterval() const
    {
      return mAutoExportInterval;
    }

    ItemInt *autoExportIntervalItem()
    {
      return mAutoExportIntervalItem;
    }

    void setConfirm( bool v )
    {
      if (!isImmutable( QString::fromLatin1( "Confirm" ) ))
        mConfirm = v;
    }

    bool confirm() const
    {
      return mConfirm;
    }

    ItemBool *confirmItem()
    {
      return mConfirmItem;
    }

    void setDestination( int v )
    {
      if (!isImmutable( QString::fromLatin1( "Destination" ) ))
        mDestination = v;
    }

    int destination() const
    {
      return mDestination;
    }

    ItemEnum *destinationItem()
    {
      return mDestinationItem;
    }

    void setShowReminderDaemon( bool v )
    {
      if (!isImmutable( QString::fromLatin1( "ShowReminderDaemon" ) ))
        mShowReminderDaemon = v;
    }

    bool showReminderDaemon() const
    {
      return mShowReminderDaemon;
    }

    ItemBool *showReminderDaemonItem()
    {
      return mShowReminderDaemonItem;
    }

    void setTimeZoneId( const QString & v )
    {
      if (!isImmutable( QString::fromLatin1( "TimeZoneId" ) ))
        mTimeZoneId = v;
    }

    QString timeZoneId() const
    {
      return mTimeZoneId;
    }

    ItemString *timeZoneIdItem()
    {
      return mTimeZoneIdItem;
    }

    void setDayBegins( const QDateTime & v )
    {
      if (!isImmutable( QString::fromLatin1( "DayBegins" ) ))
        mDayBegins = v;
    }

    QDateTime dayBegins() const
    {
      return mDayBegins;
    }

    ItemDateTime *dayBeginsItem()
    {
      return mDayBeginsItem;
    }

    void setHolidays( const QString & v )
    {
      if (!isImmutable( QString::fromLatin1( "Holidays" ) ))
        mHolidays = v;
    }

    QString holidays() const
    {
      return mHolidays;
    }

    ItemString *holidaysItem()
    {
      return mHolidaysItem;
    }

    void setWorkingHoursStart( const QDateTime & v )
    {
      if (!isImmutable( QString::fromLatin1( "WorkingHoursStart" ) ))
        mWorkingHoursStart = v;
    }

    QDateTime workingHoursStart() const
    {
      return mWorkingHoursStart;
    }

    ItemDateTime *workingHoursStartItem()
    {
      return mWorkingHoursStartItem;
    }

    void setWorkingHoursEnd( const QDateTime & v )
    {
      if (!isImmutable( QString::fromLatin1( "WorkingHoursEnd" ) ))
        mWorkingHoursEnd = v;
    }

    QDateTime workingHoursEnd() const
    {
      return mWorkingHoursEnd;
    }

    ItemDateTime *workingHoursEndItem()
    {
      return mWorkingHoursEndItem;
    }

    void setExcludeHolidays( bool v )
    {
      if (!isImmutable( QString::fromLatin1( "ExcludeHolidays" ) ))
        mExcludeHolidays = v;
    }

    bool excludeHolidays() const
    {
      return mExcludeHolidays;
    }

    ItemBool *excludeHolidaysItem()
    {
      return mExcludeHolidaysItem;
    }

    void setColorMonthBusyDaysEnabled( bool v )
    {
      if (!isImmutable( QString::fromLatin1( "ColorMonthBusyDaysEnabled" ) ))
        mColorMonthBusyDaysEnabled = v;
    }

    bool colorMonthBusyDaysEnabled() const
    {
      return mColorMonthBusyDaysEnabled;
    }

    ItemBool *colorMonthBusyDaysEnabledItem()
    {
      return mColorMonthBusyDaysEnabledItem;
    }

    void setEnableToolTips( bool v )
    {
      if (!isImmutable( QString::fromLatin1( "EnableToolTips" ) ))
        mEnableToolTips = v;
    }

    bool enableToolTips() const
    {
      return mEnableToolTips;
    }

    ItemBool *enableToolTipsItem()
    {
      return mEnableToolTipsItem;
    }

    void setTodosUseCategoryColors( bool v )
    {
      if (!isImmutable( QString::fromLatin1( "TodosUseCategoryColors" ) ))
        mTodosUseCategoryColors = v;
    }

    bool todosUseCategoryColors() const
    {
      return mTodosUseCategoryColors;
    }

    ItemBool *todosUseCategoryColorsItem()
    {
      return mTodosUseCategoryColorsItem;
    }

    void setNextXDays( int v )
    {
      if (!isImmutable( QString::fromLatin1( "NextXDays" ) ))
        mNextXDays = v;
    }

    int nextXDays() const
    {
      return mNextXDays;
    }

    ItemInt *nextXDaysItem()
    {
      return mNextXDaysItem;
    }

    void setDailyRecur( bool v )
    {
      if (!isImmutable( QString::fromLatin1( "DailyRecur" ) ))
        mDailyRecur = v;
    }

    bool dailyRecur() const
    {
      return mDailyRecur;
    }

    ItemBool *dailyRecurItem()
    {
      return mDailyRecurItem;
    }

    void setWeeklyRecur( bool v )
    {
      if (!isImmutable( QString::fromLatin1( "WeeklyRecur" ) ))
        mWeeklyRecur = v;
    }

    bool weeklyRecur() const
    {
      return mWeeklyRecur;
    }

    ItemBool *weeklyRecurItem()
    {
      return mWeeklyRecurItem;
    }

    void setHighlightTodos( bool v )
    {
      if (!isImmutable( QString::fromLatin1( "HighlightTodos" ) ))
        mHighlightTodos = v;
    }

    bool highlightTodos() const
    {
      return mHighlightTodos;
    }

    ItemBool *highlightTodosItem()
    {
      return mHighlightTodosItem;
    }

    void setHighlightJournals( bool v )
    {
      if (!isImmutable( QString::fromLatin1( "HighlightJournals" ) ))
        mHighlightJournals = v;
    }

    bool highlightJournals() const
    {
      return mHighlightJournals;
    }

    ItemBool *highlightJournalsItem()
    {
      return mHighlightJournalsItem;
    }

    void setWeekNumbersShowWork( bool v )
    {
      if (!isImmutable( QString::fromLatin1( "WeekNumbersShowWork" ) ))
        mWeekNumbersShowWork = v;
    }

    bool weekNumbersShowWork() const
    {
      return mWeekNumbersShowWork;
    }

    ItemBool *weekNumbersShowWorkItem()
    {
      return mWeekNumbersShowWorkItem;
    }

    void setHourSize( int v )
    {
      if (v < 4)
      {
        kDebug() << "setHourSize: value " << v << " is less than the minimum value of 4";
        v = 4;
      }

      if (v > 30)
      {
        kDebug() << "setHourSize: value " << v << " is greater than the maximum value of 30";
        v = 30;
      }

      if (!isImmutable( QString::fromLatin1( "HourSize" ) ))
        mHourSize = v;
    }

    int hourSize() const
    {
      return mHourSize;
    }

    ItemInt *hourSizeItem()
    {
      return mHourSizeItem;
    }

    void setEnableAgendaItemIcons( bool v )
    {
      if (!isImmutable( QString::fromLatin1( "EnableAgendaItemIcons" ) ))
        mEnableAgendaItemIcons = v;
    }

    bool enableAgendaItemIcons() const
    {
      return mEnableAgendaItemIcons;
    }

    ItemBool *enableAgendaItemIconsItem()
    {
      return mEnableAgendaItemIconsItem;
    }

    void setShowTodosAgendaView( bool v )
    {
      if (!isImmutable( QString::fromLatin1( "ShowTodosAgendaView" ) ))
        mShowTodosAgendaView = v;
    }

    bool showTodosAgendaView() const
    {
      return mShowTodosAgendaView;
    }

    ItemBool *showTodosAgendaViewItem()
    {
      return mShowTodosAgendaViewItem;
    }

    void setMarcusBainsEnabled( bool v )
    {
      if (!isImmutable( QString::fromLatin1( "MarcusBainsEnabled" ) ))
        mMarcusBainsEnabled = v;
    }

    bool marcusBainsEnabled() const
    {
      return mMarcusBainsEnabled;
    }

    ItemBool *marcusBainsEnabledItem()
    {
      return mMarcusBainsEnabledItem;
    }

    void setMarcusBainsShowSeconds( bool v )
    {
      if (!isImmutable( QString::fromLatin1( "MarcusBainsShowSeconds" ) ))
        mMarcusBainsShowSeconds = v;
    }

    bool marcusBainsShowSeconds() const
    {
      return mMarcusBainsShowSeconds;
    }

    ItemBool *marcusBainsShowSecondsItem()
    {
      return mMarcusBainsShowSecondsItem;
    }

    void setSelectionStartsEditor( bool v )
    {
      if (!isImmutable( QString::fromLatin1( "SelectionStartsEditor" ) ))
        mSelectionStartsEditor = v;
    }

    bool selectionStartsEditor() const
    {
      return mSelectionStartsEditor;
    }

    ItemBool *selectionStartsEditorItem()
    {
      return mSelectionStartsEditorItem;
    }

    void setAgendaViewColors( int v )
    {
      if (!isImmutable( QString::fromLatin1( "AgendaViewColors" ) ))
        mAgendaViewColors = v;
    }

    int agendaViewColors() const
    {
      return mAgendaViewColors;
    }

    ItemEnum *agendaViewColorsItem()
    {
      return mAgendaViewColorsItem;
    }

    void setColorBusyDaysEnabled( bool v )
    {
      if (!isImmutable( QString::fromLatin1( "ColorBusyDaysEnabled" ) ))
        mColorBusyDaysEnabled = v;
    }

    bool colorBusyDaysEnabled() const
    {
      return mColorBusyDaysEnabled;
    }

    ItemBool *colorBusyDaysEnabledItem()
    {
      return mColorBusyDaysEnabledItem;
    }

    void setAgendaViewCalendarDisplay( int v )
    {
      if (!isImmutable( QString::fromLatin1( "AgendaViewCalendarDisplay" ) ))
        mAgendaViewCalendarDisplay = v;
    }

    int agendaViewCalendarDisplay() const
    {
      return mAgendaViewCalendarDisplay;
    }

    ItemEnum *agendaViewCalendarDisplayItem()
    {
      return mAgendaViewCalendarDisplayItem;
    }

    void setEnableMonthItemIcons( bool v )
    {
      if (!isImmutable( QString::fromLatin1( "EnableMonthItemIcons" ) ))
        mEnableMonthItemIcons = v;
    }

    bool enableMonthItemIcons() const
    {
      return mEnableMonthItemIcons;
    }

    ItemBool *enableMonthItemIconsItem()
    {
      return mEnableMonthItemIconsItem;
    }

    void setShowTimeInMonthView( bool v )
    {
      if (!isImmutable( QString::fromLatin1( "ShowTimeInMonthView" ) ))
        mShowTimeInMonthView = v;
    }

    bool showTimeInMonthView() const
    {
      return mShowTimeInMonthView;
    }

    ItemBool *showTimeInMonthViewItem()
    {
      return mShowTimeInMonthViewItem;
    }

    void setShowTodosMonthView( bool v )
    {
      if (!isImmutable( QString::fromLatin1( "ShowTodosMonthView" ) ))
        mShowTodosMonthView = v;
    }

    bool showTodosMonthView() const
    {
      return mShowTodosMonthView;
    }

    ItemBool *showTodosMonthViewItem()
    {
      return mShowTodosMonthViewItem;
    }

    void setShowJournalsMonthView( bool v )
    {
      if (!isImmutable( QString::fromLatin1( "ShowJournalsMonthView" ) ))
        mShowJournalsMonthView = v;
    }

    bool showJournalsMonthView() const
    {
      return mShowJournalsMonthView;
    }

    ItemBool *showJournalsMonthViewItem()
    {
      return mShowJournalsMonthViewItem;
    }

    void setFullViewMonth( bool v )
    {
      if (!isImmutable( QString::fromLatin1( "FullViewMonth" ) ))
        mFullViewMonth = v;
    }

    bool fullViewMonth() const
    {
      return mFullViewMonth;
    }

    ItemBool *fullViewMonthItem()
    {
      return mFullViewMonthItem;
    }

    void setMonthViewColors( int v )
    {
      if (!isImmutable( QString::fromLatin1( "MonthViewColors" ) ))
        mMonthViewColors = v;
    }

    int monthViewColors() const
    {
      return mMonthViewColors;
    }

    ItemEnum *monthViewColorsItem()
    {
      return mMonthViewColorsItem;
    }

    void setSortCompletedTodosSeparately( bool v )
    {
      if (!isImmutable( QString::fromLatin1( "SortCompletedTodosSeparately" ) ))
        mSortCompletedTodosSeparately = v;
    }

    bool sortCompletedTodosSeparately() const
    {
      return mSortCompletedTodosSeparately;
    }

    ItemBool *sortCompletedTodosSeparatelyItem()
    {
      return mSortCompletedTodosSeparatelyItem;
    }

    void setFullViewTodo( bool v )
    {
      if (!isImmutable( QString::fromLatin1( "FullViewTodo" ) ))
        mFullViewTodo = v;
    }

    bool fullViewTodo() const
    {
      return mFullViewTodo;
    }

    ItemBool *fullViewTodoItem()
    {
      return mFullViewTodoItem;
    }

    void setFlatListTodo( bool v )
    {
      if (!isImmutable( QString::fromLatin1( "FlatListTodo" ) ))
        mFlatListTodo = v;
    }

    bool flatListTodo() const
    {
      return mFlatListTodo;
    }

    ItemBool *flatListTodoItem()
    {
      return mFlatListTodoItem;
    }

    void setRecordTodosInJournals( bool v )
    {
      if (!isImmutable( QString::fromLatin1( "RecordTodosInJournals" ) ))
        mRecordTodosInJournals = v;
    }

    bool recordTodosInJournals() const
    {
      return mRecordTodosInJournals;
    }

    ItemBool *recordTodosInJournalsItem()
    {
      return mRecordTodosInJournalsItem;
    }

    void setHolidayColor( const QColor & v )
    {
      if (!isImmutable( QString::fromLatin1( "HolidayColor" ) ))
        mHolidayColor = v;
    }

    QColor holidayColor() const
    {
      return mHolidayColor;
    }

    ItemColor *holidayColorItem()
    {
      return mHolidayColorItem;
    }

    void setAgendaBgColor( const QColor & v )
    {
      if (!isImmutable( QString::fromLatin1( "AgendaBgColor" ) ))
        mAgendaBgColor = v;
    }

    QColor agendaBgColor() const
    {
      return mAgendaBgColor;
    }

    ItemColor *agendaBgColorItem()
    {
      return mAgendaBgColorItem;
    }

    void setAgendaMarcusBainsLineLineColor( const QColor & v )
    {
      if (!isImmutable( QString::fromLatin1( "AgendaMarcusBainsLineLineColor" ) ))
        mAgendaMarcusBainsLineLineColor = v;
    }

    QColor agendaMarcusBainsLineLineColor() const
    {
      return mAgendaMarcusBainsLineLineColor;
    }

    ItemColor *agendaMarcusBainsLineLineColorItem()
    {
      return mAgendaMarcusBainsLineLineColorItem;
    }

    void setViewBgBusyColor( const QColor & v )
    {
      if (!isImmutable( QString::fromLatin1( "ViewBgBusyColor" ) ))
        mViewBgBusyColor = v;
    }

    QColor viewBgBusyColor() const
    {
      return mViewBgBusyColor;
    }

    ItemColor *viewBgBusyColorItem()
    {
      return mViewBgBusyColorItem;
    }

    void setWorkingHoursColor( const QColor & v )
    {
      if (!isImmutable( QString::fromLatin1( "WorkingHoursColor" ) ))
        mWorkingHoursColor = v;
    }

    QColor workingHoursColor() const
    {
      return mWorkingHoursColor;
    }

    ItemColor *workingHoursColorItem()
    {
      return mWorkingHoursColorItem;
    }

    void setTodoDueTodayColor( const QColor & v )
    {
      if (!isImmutable( QString::fromLatin1( "TodoDueTodayColor" ) ))
        mTodoDueTodayColor = v;
    }

    QColor todoDueTodayColor() const
    {
      return mTodoDueTodayColor;
    }

    ItemColor *todoDueTodayColorItem()
    {
      return mTodoDueTodayColorItem;
    }

    void setTodoOverdueColor( const QColor & v )
    {
      if (!isImmutable( QString::fromLatin1( "TodoOverdueColor" ) ))
        mTodoOverdueColor = v;
    }

    QColor todoOverdueColor() const
    {
      return mTodoOverdueColor;
    }

    ItemColor *todoOverdueColorItem()
    {
      return mTodoOverdueColorItem;
    }

    void setAgendaTimeLabelsFont( const QFont & v )
    {
      if (!isImmutable( QString::fromLatin1( "AgendaTimeLabelsFont" ) ))
        mAgendaTimeLabelsFont = v;
    }

    QFont agendaTimeLabelsFont() const
    {
      return mAgendaTimeLabelsFont;
    }

    ItemFont *agendaTimeLabelsFontItem()
    {
      return mAgendaTimeLabelsFontItem;
    }

    void setMonthViewFont( const QFont & v )
    {
      if (!isImmutable( QString::fromLatin1( "MonthViewFont" ) ))
        mMonthViewFont = v;
    }

    QFont monthViewFont() const
    {
      return mMonthViewFont;
    }

    ItemFont *monthViewFontItem()
    {
      return mMonthViewFontItem;
    }

    void setAgendaViewFont( const QFont & v )
    {
      if (!isImmutable( QString::fromLatin1( "AgendaViewFont" ) ))
        mAgendaViewFont = v;
    }

    QFont agendaViewFont() const
    {
      return mAgendaViewFont;
    }

    ItemFont *agendaViewFontItem()
    {
      return mAgendaViewFontItem;
    }

    void setAgendaMarcusBainsLineFont( const QFont & v )
    {
      if (!isImmutable( QString::fromLatin1( "AgendaMarcusBainsLineFont" ) ))
        mAgendaMarcusBainsLineFont = v;
    }

    QFont agendaMarcusBainsLineFont() const
    {
      return mAgendaMarcusBainsLineFont;
    }

    ItemFont *agendaMarcusBainsLineFontItem()
    {
      return mAgendaMarcusBainsLineFontItem;
    }

    void setSelectedPlugins( const QStringList & v )
    {
      if (!isImmutable( QString::fromLatin1( "SelectedPlugins" ) ))
        mSelectedPlugins = v;
    }

    QStringList selectedPlugins() const
    {
      return mSelectedPlugins;
    }

    ItemStringList *selectedPluginsItem()
    {
      return mSelectedPluginsItem;
    }

    void setEnableQuickTodo( bool v )
    {
      if (!isImmutable( QString::fromLatin1( "EnableQuickTodo" ) ))
        mEnableQuickTodo = v;
    }

    bool enableQuickTodo() const
    {
      return mEnableQuickTodo;
    }

    ItemBool *enableQuickTodoItem()
    {
      return mEnableQuickTodoItem;
    }

    void setEnableTodoQuickSearch( bool v )
    {
      if (!isImmutable( QString::fromLatin1( "EnableTodoQuickSearch" ) ))
        mEnableTodoQuickSearch = v;
    }

    bool enableTodoQuickSearch() const
    {
      return mEnableTodoQuickSearch;
    }

    ItemBool *enableTodoQuickSearchItem()
    {
      return mEnableTodoQuickSearchItem;
    }

    void setDefaultTodoAttachMethod( int v )
    {
      if (!isImmutable( QString::fromLatin1( "DefaultTodoAttachMethod" ) ))
        mDefaultTodoAttachMethod = v;
    }

    int defaultTodoAttachMethod() const
    {
      return mDefaultTodoAttachMethod;
    }

    ItemEnum *defaultTodoAttachMethodItem()
    {
      return mDefaultTodoAttachMethodItem;
    }

    void setCompactDialogs( bool v )
    {
      if (!isImmutable( QString::fromLatin1( "CompactDialogs" ) ))
        mCompactDialogs = v;
    }

    bool compactDialogs() const
    {
      return mCompactDialogs;
    }

    ItemBool *compactDialogsItem()
    {
      return mCompactDialogsItem;
    }

    void setShowMenuBar( bool v )
    {
      if (!isImmutable( QString::fromLatin1( "ShowMenuBar" ) ))
        mShowMenuBar = v;
    }

    bool showMenuBar() const
    {
      return mShowMenuBar;
    }

    ItemBool *showMenuBarItem()
    {
      return mShowMenuBarItem;
    }

    void setWorkWeekMask( int v )
    {
      if (!isImmutable( QString::fromLatin1( "WorkWeekMask" ) ))
        mWorkWeekMask = v;
    }

    int workWeekMask() const
    {
      return mWorkWeekMask;
    }

    ItemInt *workWeekMaskItem()
    {
      return mWorkWeekMaskItem;
    }

    void setDefaultResourceColorSeed( int v )
    {
      if (!isImmutable( QString::fromLatin1( "DefaultResourceColorSeed" ) ))
        mDefaultResourceColorSeed = v;
    }

    int defaultResourceColorSeed() const
    {
      return mDefaultResourceColorSeed;
    }

    ItemInt *defaultResourceColorSeedItem()
    {
      return mDefaultResourceColorSeedItem;
    }

    void setDefaultResourceColors( const QStringList & v )
    {
      if (!isImmutable( QString::fromLatin1( "DefaultResourceColors" ) ))
        mDefaultResourceColors = v;
    }

    QStringList defaultResourceColors() const
    {
      return mDefaultResourceColors;
    }

    ItemStringList *defaultResourceColorsItem()
    {
      return mDefaultResourceColorsItem;
    }

    void setAssignDefaultResourceColors( bool v )
    {
      if (!isImmutable( QString::fromLatin1( "AssignDefaultResourceColors" ) ))
        mAssignDefaultResourceColors = v;
    }

    bool assignDefaultResourceColors() const
    {
      return mAssignDefaultResourceColors;
    }

    ItemBool *assignDefaultResourceColorsItem()
    {
      return mAssignDefaultResourceColorsItem;
    }

    void setDecorationsAtMonthViewTop( const QStringList & v )
    {
      if (!isImmutable( QString::fromLatin1( "DecorationsAtMonthViewTop" ) ))
        mDecorationsAtMonthViewTop = v;
    }

    QStringList decorationsAtMonthViewTop() const
    {
      return mDecorationsAtMonthViewTop;
    }

    ItemStringList *decorationsAtMonthViewTopItem()
    {
      return mDecorationsAtMonthViewTopItem;
    }

    void setDecorationsAtAgendaViewTop( const QStringList & v )
    {
      if (!isImmutable( QString::fromLatin1( "DecorationsAtAgendaViewTop" ) ))
        mDecorationsAtAgendaViewTop = v;
    }

    QStringList decorationsAtAgendaViewTop() const
    {
      return mDecorationsAtAgendaViewTop;
    }

    ItemStringList *decorationsAtAgendaViewTopItem()
    {
      return mDecorationsAtAgendaViewTopItem;
    }

    void setDecorationsAtAgendaViewBottom( const QStringList & v )
    {
      if (!isImmutable( QString::fromLatin1( "DecorationsAtAgendaViewBottom" ) ))
        mDecorationsAtAgendaViewBottom = v;
    }

    QStringList decorationsAtAgendaViewBottom() const
    {
      return mDecorationsAtAgendaViewBottom;
    }

    ItemStringList *decorationsAtAgendaViewBottomItem()
    {
      return mDecorationsAtAgendaViewBottomItem;
    }

    void setAgendaGridBackgroundColor( const QColor & v )
    {
      if (!isImmutable( QString::fromLatin1( "AgendaGridBackgroundColor" ) ))
        mAgendaGridBackgroundColor = v;
    }

    QColor agendaGridBackgroundColor() const
    {
      return mAgendaGridBackgroundColor;
    }

    ItemColor *agendaGridBackgroundColorItem()
    {
      return mAgendaGridBackgroundColorItem;
    }

    void setAgendaGridBackgroundImage( const QString & v )
    {
      if (!isImmutable( QString::fromLatin1( "AgendaGridBackgroundImage" ) ))
        mAgendaGridBackgroundImage = v;
    }

    QString agendaGridBackgroundImage() const
    {
      return mAgendaGridBackgroundImage;
    }

    ItemString *agendaGridBackgroundImageItem()
    {
      return mAgendaGridBackgroundImageItem;
    }

    void setAgendaGridHighlightColor( const QColor & v )
    {
      if (!isImmutable( QString::fromLatin1( "AgendaGridHighlightColor" ) ))
        mAgendaGridHighlightColor = v;
    }

    QColor agendaGridHighlightColor() const
    {
      return mAgendaGridHighlightColor;
    }

    ItemColor *agendaGridHighlightColorItem()
    {
      return mAgendaGridHighlightColorItem;
    }

    void setAgendaGridWorkHoursBackgroundImage( const QString & v )
    {
      if (!isImmutable( QString::fromLatin1( "AgendaGridWorkHoursBackgroundImage" ) ))
        mAgendaGridWorkHoursBackgroundImage = v;
    }

    QString agendaGridWorkHoursBackgroundImage() const
    {
      return mAgendaGridWorkHoursBackgroundImage;
    }

    ItemString *agendaGridWorkHoursBackgroundImageItem()
    {
      return mAgendaGridWorkHoursBackgroundImageItem;
    }

    void setAgendaCalendarItemsBackgroundColor( const QColor & v )
    {
      if (!isImmutable( QString::fromLatin1( "AgendaCalendarItemsBackgroundColor" ) ))
        mAgendaCalendarItemsBackgroundColor = v;
    }

    QColor agendaCalendarItemsBackgroundColor() const
    {
      return mAgendaCalendarItemsBackgroundColor;
    }

    ItemColor *agendaCalendarItemsBackgroundColorItem()
    {
      return mAgendaCalendarItemsBackgroundColorItem;
    }

    void setAgendaCalendarItemsBackgroundImage( const QString & v )
    {
      if (!isImmutable( QString::fromLatin1( "AgendaCalendarItemsBackgroundImage" ) ))
        mAgendaCalendarItemsBackgroundImage = v;
    }

    QString agendaCalendarItemsBackgroundImage() const
    {
      return mAgendaCalendarItemsBackgroundImage;
    }

    ItemString *agendaCalendarItemsBackgroundImageItem()
    {
      return mAgendaCalendarItemsBackgroundImageItem;
    }

    void setAgendaCalendarItemsFont( const QFont & v )
    {
      if (!isImmutable( QString::fromLatin1( "AgendaCalendarItemsFont" ) ))
        mAgendaCalendarItemsFont = v;
    }

    QFont agendaCalendarItemsFont() const
    {
      return mAgendaCalendarItemsFont;
    }

    ItemFont *agendaCalendarItemsFontItem()
    {
      return mAgendaCalendarItemsFontItem;
    }

    void setAgendaCalendarItemsFrameColor( const QColor & v )
    {
      if (!isImmutable( QString::fromLatin1( "AgendaCalendarItemsFrameColor" ) ))
        mAgendaCalendarItemsFrameColor = v;
    }

    QColor agendaCalendarItemsFrameColor() const
    {
      return mAgendaCalendarItemsFrameColor;
    }

    ItemColor *agendaCalendarItemsFrameColorItem()
    {
      return mAgendaCalendarItemsFrameColorItem;
    }

    void setAgendaCalendarItemsIcon( const QString & v )
    {
      if (!isImmutable( QString::fromLatin1( "AgendaCalendarItemsIcon" ) ))
        mAgendaCalendarItemsIcon = v;
    }

    QString agendaCalendarItemsIcon() const
    {
      return mAgendaCalendarItemsIcon;
    }

    ItemString *agendaCalendarItemsIconItem()
    {
      return mAgendaCalendarItemsIconItem;
    }

    void setAgendaCalendarItemsEventsBackgroundImage( const QString & v )
    {
      if (!isImmutable( QString::fromLatin1( "AgendaCalendarItemsEventsBackgroundImage" ) ))
        mAgendaCalendarItemsEventsBackgroundImage = v;
    }

    QString agendaCalendarItemsEventsBackgroundImage() const
    {
      return mAgendaCalendarItemsEventsBackgroundImage;
    }

    ItemString *agendaCalendarItemsEventsBackgroundImageItem()
    {
      return mAgendaCalendarItemsEventsBackgroundImageItem;
    }

    void setAgendaCalendarItemsEventsFont( const QFont & v )
    {
      if (!isImmutable( QString::fromLatin1( "AgendaCalendarItemsEventsFont" ) ))
        mAgendaCalendarItemsEventsFont = v;
    }

    QFont agendaCalendarItemsEventsFont() const
    {
      return mAgendaCalendarItemsEventsFont;
    }

    ItemFont *agendaCalendarItemsEventsFontItem()
    {
      return mAgendaCalendarItemsEventsFontItem;
    }

    void setAgendaCalendarItemsEventsFrameColor( const QColor & v )
    {
      if (!isImmutable( QString::fromLatin1( "AgendaCalendarItemsEventsFrameColor" ) ))
        mAgendaCalendarItemsEventsFrameColor = v;
    }

    QColor agendaCalendarItemsEventsFrameColor() const
    {
      return mAgendaCalendarItemsEventsFrameColor;
    }

    ItemColor *agendaCalendarItemsEventsFrameColorItem()
    {
      return mAgendaCalendarItemsEventsFrameColorItem;
    }

    void setAgendaCalendarItemsEventsIcon( const QString & v )
    {
      if (!isImmutable( QString::fromLatin1( "AgendaCalendarItemsEventsIcon" ) ))
        mAgendaCalendarItemsEventsIcon = v;
    }

    QString agendaCalendarItemsEventsIcon() const
    {
      return mAgendaCalendarItemsEventsIcon;
    }

    ItemString *agendaCalendarItemsEventsIconItem()
    {
      return mAgendaCalendarItemsEventsIconItem;
    }

    void setAgendaCalendarItemsToDosBackgroundColor( const QColor & v )
    {
      if (!isImmutable( QString::fromLatin1( "AgendaCalendarItemsToDosBackgroundColor" ) ))
        mAgendaCalendarItemsToDosBackgroundColor = v;
    }

    QColor agendaCalendarItemsToDosBackgroundColor() const
    {
      return mAgendaCalendarItemsToDosBackgroundColor;
    }

    ItemColor *agendaCalendarItemsToDosBackgroundColorItem()
    {
      return mAgendaCalendarItemsToDosBackgroundColorItem;
    }

    void setAgendaCalendarItemsToDosBackgroundImage( const QString & v )
    {
      if (!isImmutable( QString::fromLatin1( "AgendaCalendarItemsToDosBackgroundImage" ) ))
        mAgendaCalendarItemsToDosBackgroundImage = v;
    }

    QString agendaCalendarItemsToDosBackgroundImage() const
    {
      return mAgendaCalendarItemsToDosBackgroundImage;
    }

    ItemString *agendaCalendarItemsToDosBackgroundImageItem()
    {
      return mAgendaCalendarItemsToDosBackgroundImageItem;
    }

    void setAgendaCalendarItemsToDosFont( const QFont & v )
    {
      if (!isImmutable( QString::fromLatin1( "AgendaCalendarItemsToDosFont" ) ))
        mAgendaCalendarItemsToDosFont = v;
    }

    QFont agendaCalendarItemsToDosFont() const
    {
      return mAgendaCalendarItemsToDosFont;
    }

    ItemFont *agendaCalendarItemsToDosFontItem()
    {
      return mAgendaCalendarItemsToDosFontItem;
    }

    void setAgendaCalendarItemsToDosFrameColor( const QColor & v )
    {
      if (!isImmutable( QString::fromLatin1( "AgendaCalendarItemsToDosFrameColor" ) ))
        mAgendaCalendarItemsToDosFrameColor = v;
    }

    QColor agendaCalendarItemsToDosFrameColor() const
    {
      return mAgendaCalendarItemsToDosFrameColor;
    }

    ItemColor *agendaCalendarItemsToDosFrameColorItem()
    {
      return mAgendaCalendarItemsToDosFrameColorItem;
    }

    void setAgendaCalendarItemsToDosIcon( const QString & v )
    {
      if (!isImmutable( QString::fromLatin1( "AgendaCalendarItemsToDosIcon" ) ))
        mAgendaCalendarItemsToDosIcon = v;
    }

    QString agendaCalendarItemsToDosIcon() const
    {
      return mAgendaCalendarItemsToDosIcon;
    }

    ItemString *agendaCalendarItemsToDosIconItem()
    {
      return mAgendaCalendarItemsToDosIconItem;
    }

    void setAgendaCalendarItemsToDosDueTodayBackgroundImage( const QString & v )
    {
      if (!isImmutable( QString::fromLatin1( "AgendaCalendarItemsToDosDueTodayBackgroundImage" ) ))
        mAgendaCalendarItemsToDosDueTodayBackgroundImage = v;
    }

    QString agendaCalendarItemsToDosDueTodayBackgroundImage() const
    {
      return mAgendaCalendarItemsToDosDueTodayBackgroundImage;
    }

    ItemString *agendaCalendarItemsToDosDueTodayBackgroundImageItem()
    {
      return mAgendaCalendarItemsToDosDueTodayBackgroundImageItem;
    }

    void setAgendaCalendarItemsToDosDueTodayFont( const QFont & v )
    {
      if (!isImmutable( QString::fromLatin1( "AgendaCalendarItemsToDosDueTodayFont" ) ))
        mAgendaCalendarItemsToDosDueTodayFont = v;
    }

    QFont agendaCalendarItemsToDosDueTodayFont() const
    {
      return mAgendaCalendarItemsToDosDueTodayFont;
    }

    ItemFont *agendaCalendarItemsToDosDueTodayFontItem()
    {
      return mAgendaCalendarItemsToDosDueTodayFontItem;
    }

    void setAgendaCalendarItemsToDosDueTodayFrameColor( const QColor & v )
    {
      if (!isImmutable( QString::fromLatin1( "AgendaCalendarItemsToDosDueTodayFrameColor" ) ))
        mAgendaCalendarItemsToDosDueTodayFrameColor = v;
    }

    QColor agendaCalendarItemsToDosDueTodayFrameColor() const
    {
      return mAgendaCalendarItemsToDosDueTodayFrameColor;
    }

    ItemColor *agendaCalendarItemsToDosDueTodayFrameColorItem()
    {
      return mAgendaCalendarItemsToDosDueTodayFrameColorItem;
    }

    void setAgendaCalendarItemsToDosDueTodayIcon( const QString & v )
    {
      if (!isImmutable( QString::fromLatin1( "AgendaCalendarItemsToDosDueTodayIcon" ) ))
        mAgendaCalendarItemsToDosDueTodayIcon = v;
    }

    QString agendaCalendarItemsToDosDueTodayIcon() const
    {
      return mAgendaCalendarItemsToDosDueTodayIcon;
    }

    ItemString *agendaCalendarItemsToDosDueTodayIconItem()
    {
      return mAgendaCalendarItemsToDosDueTodayIconItem;
    }

    void setAgendaCalendarItemsToDosOverdueBackgroundImage( const QString & v )
    {
      if (!isImmutable( QString::fromLatin1( "AgendaCalendarItemsToDosOverdueBackgroundImage" ) ))
        mAgendaCalendarItemsToDosOverdueBackgroundImage = v;
    }

    QString agendaCalendarItemsToDosOverdueBackgroundImage() const
    {
      return mAgendaCalendarItemsToDosOverdueBackgroundImage;
    }

    ItemString *agendaCalendarItemsToDosOverdueBackgroundImageItem()
    {
      return mAgendaCalendarItemsToDosOverdueBackgroundImageItem;
    }

    void setAgendaCalendarItemsToDosOverdueFont( const QFont & v )
    {
      if (!isImmutable( QString::fromLatin1( "AgendaCalendarItemsToDosOverdueFont" ) ))
        mAgendaCalendarItemsToDosOverdueFont = v;
    }

    QFont agendaCalendarItemsToDosOverdueFont() const
    {
      return mAgendaCalendarItemsToDosOverdueFont;
    }

    ItemFont *agendaCalendarItemsToDosOverdueFontItem()
    {
      return mAgendaCalendarItemsToDosOverdueFontItem;
    }

    void setAgendaCalendarItemsToDosOverdueFrameColor( const QColor & v )
    {
      if (!isImmutable( QString::fromLatin1( "AgendaCalendarItemsToDosOverdueFrameColor" ) ))
        mAgendaCalendarItemsToDosOverdueFrameColor = v;
    }

    QColor agendaCalendarItemsToDosOverdueFrameColor() const
    {
      return mAgendaCalendarItemsToDosOverdueFrameColor;
    }

    ItemColor *agendaCalendarItemsToDosOverdueFrameColorItem()
    {
      return mAgendaCalendarItemsToDosOverdueFrameColorItem;
    }

    void setAgendaCalendarItemsToDosOverdueIcon( const QString & v )
    {
      if (!isImmutable( QString::fromLatin1( "AgendaCalendarItemsToDosOverdueIcon" ) ))
        mAgendaCalendarItemsToDosOverdueIcon = v;
    }

    QString agendaCalendarItemsToDosOverdueIcon() const
    {
      return mAgendaCalendarItemsToDosOverdueIcon;
    }

    ItemString *agendaCalendarItemsToDosOverdueIconItem()
    {
      return mAgendaCalendarItemsToDosOverdueIconItem;
    }

    void setAgendaHolidaysBackgroundColor( const QColor & v )
    {
      if (!isImmutable( QString::fromLatin1( "AgendaHolidaysBackgroundColor" ) ))
        mAgendaHolidaysBackgroundColor = v;
    }

    QColor agendaHolidaysBackgroundColor() const
    {
      return mAgendaHolidaysBackgroundColor;
    }

    ItemColor *agendaHolidaysBackgroundColorItem()
    {
      return mAgendaHolidaysBackgroundColorItem;
    }

    void setAgendaHolidaysBackgroundImage( const QString & v )
    {
      if (!isImmutable( QString::fromLatin1( "AgendaHolidaysBackgroundImage" ) ))
        mAgendaHolidaysBackgroundImage = v;
    }

    QString agendaHolidaysBackgroundImage() const
    {
      return mAgendaHolidaysBackgroundImage;
    }

    ItemString *agendaHolidaysBackgroundImageItem()
    {
      return mAgendaHolidaysBackgroundImageItem;
    }

    void setMonthGridBackgroundColor( const QColor & v )
    {
      if (!isImmutable( QString::fromLatin1( "MonthGridBackgroundColor" ) ))
        mMonthGridBackgroundColor = v;
    }

    QColor monthGridBackgroundColor() const
    {
      return mMonthGridBackgroundColor;
    }

    ItemColor *monthGridBackgroundColorItem()
    {
      return mMonthGridBackgroundColorItem;
    }

    void setMonthGridBackgroundImage( const QString & v )
    {
      if (!isImmutable( QString::fromLatin1( "MonthGridBackgroundImage" ) ))
        mMonthGridBackgroundImage = v;
    }

    QString monthGridBackgroundImage() const
    {
      return mMonthGridBackgroundImage;
    }

    ItemString *monthGridBackgroundImageItem()
    {
      return mMonthGridBackgroundImageItem;
    }

    void setMonthGridHighlightColor( const QColor & v )
    {
      if (!isImmutable( QString::fromLatin1( "MonthGridHighlightColor" ) ))
        mMonthGridHighlightColor = v;
    }

    QColor monthGridHighlightColor() const
    {
      return mMonthGridHighlightColor;
    }

    ItemColor *monthGridHighlightColorItem()
    {
      return mMonthGridHighlightColorItem;
    }

    void setMonthGridWorkHoursBackgroundColor( const QColor & v )
    {
      if (!isImmutable( QString::fromLatin1( "MonthGridWorkHoursBackgroundColor" ) ))
        mMonthGridWorkHoursBackgroundColor = v;
    }

    QColor monthGridWorkHoursBackgroundColor() const
    {
      return mMonthGridWorkHoursBackgroundColor;
    }

    ItemColor *monthGridWorkHoursBackgroundColorItem()
    {
      return mMonthGridWorkHoursBackgroundColorItem;
    }

    void setMonthGridWorkHoursBackgroundImage( const QString & v )
    {
      if (!isImmutable( QString::fromLatin1( "MonthGridWorkHoursBackgroundImage" ) ))
        mMonthGridWorkHoursBackgroundImage = v;
    }

    QString monthGridWorkHoursBackgroundImage() const
    {
      return mMonthGridWorkHoursBackgroundImage;
    }

    ItemString *monthGridWorkHoursBackgroundImageItem()
    {
      return mMonthGridWorkHoursBackgroundImageItem;
    }

    void setMonthCalendarItemsBackgroundColor( const QColor & v )
    {
      if (!isImmutable( QString::fromLatin1( "MonthCalendarItemsBackgroundColor" ) ))
        mMonthCalendarItemsBackgroundColor = v;
    }

    QColor monthCalendarItemsBackgroundColor() const
    {
      return mMonthCalendarItemsBackgroundColor;
    }

    ItemColor *monthCalendarItemsBackgroundColorItem()
    {
      return mMonthCalendarItemsBackgroundColorItem;
    }

    void setMonthCalendarItemsBackgroundImage( const QString & v )
    {
      if (!isImmutable( QString::fromLatin1( "MonthCalendarItemsBackgroundImage" ) ))
        mMonthCalendarItemsBackgroundImage = v;
    }

    QString monthCalendarItemsBackgroundImage() const
    {
      return mMonthCalendarItemsBackgroundImage;
    }

    ItemString *monthCalendarItemsBackgroundImageItem()
    {
      return mMonthCalendarItemsBackgroundImageItem;
    }

    void setMonthCalendarItemsFont( const QFont & v )
    {
      if (!isImmutable( QString::fromLatin1( "MonthCalendarItemsFont" ) ))
        mMonthCalendarItemsFont = v;
    }

    QFont monthCalendarItemsFont() const
    {
      return mMonthCalendarItemsFont;
    }

    ItemFont *monthCalendarItemsFontItem()
    {
      return mMonthCalendarItemsFontItem;
    }

    void setMonthCalendarItemsFrameColor( const QColor & v )
    {
      if (!isImmutable( QString::fromLatin1( "MonthCalendarItemsFrameColor" ) ))
        mMonthCalendarItemsFrameColor = v;
    }

    QColor monthCalendarItemsFrameColor() const
    {
      return mMonthCalendarItemsFrameColor;
    }

    ItemColor *monthCalendarItemsFrameColorItem()
    {
      return mMonthCalendarItemsFrameColorItem;
    }

    void setMonthCalendarItemsIcon( const QString & v )
    {
      if (!isImmutable( QString::fromLatin1( "MonthCalendarItemsIcon" ) ))
        mMonthCalendarItemsIcon = v;
    }

    QString monthCalendarItemsIcon() const
    {
      return mMonthCalendarItemsIcon;
    }

    ItemString *monthCalendarItemsIconItem()
    {
      return mMonthCalendarItemsIconItem;
    }

    void setMonthCalendarItemsEventsBackgroundColor( const QColor & v )
    {
      if (!isImmutable( QString::fromLatin1( "MonthCalendarItemsEventsBackgroundColor" ) ))
        mMonthCalendarItemsEventsBackgroundColor = v;
    }

    QColor monthCalendarItemsEventsBackgroundColor() const
    {
      return mMonthCalendarItemsEventsBackgroundColor;
    }

    ItemColor *monthCalendarItemsEventsBackgroundColorItem()
    {
      return mMonthCalendarItemsEventsBackgroundColorItem;
    }

    void setMonthCalendarItemsEventsBackgroundImage( const QString & v )
    {
      if (!isImmutable( QString::fromLatin1( "MonthCalendarItemsEventsBackgroundImage" ) ))
        mMonthCalendarItemsEventsBackgroundImage = v;
    }

    QString monthCalendarItemsEventsBackgroundImage() const
    {
      return mMonthCalendarItemsEventsBackgroundImage;
    }

    ItemString *monthCalendarItemsEventsBackgroundImageItem()
    {
      return mMonthCalendarItemsEventsBackgroundImageItem;
    }

    void setMonthCalendarItemsEventsFont( const QFont & v )
    {
      if (!isImmutable( QString::fromLatin1( "MonthCalendarItemsEventsFont" ) ))
        mMonthCalendarItemsEventsFont = v;
    }

    QFont monthCalendarItemsEventsFont() const
    {
      return mMonthCalendarItemsEventsFont;
    }

    ItemFont *monthCalendarItemsEventsFontItem()
    {
      return mMonthCalendarItemsEventsFontItem;
    }

    void setMonthCalendarItemsEventsFrameColor( const QColor & v )
    {
      if (!isImmutable( QString::fromLatin1( "MonthCalendarItemsEventsFrameColor" ) ))
        mMonthCalendarItemsEventsFrameColor = v;
    }

    QColor monthCalendarItemsEventsFrameColor() const
    {
      return mMonthCalendarItemsEventsFrameColor;
    }

    ItemColor *monthCalendarItemsEventsFrameColorItem()
    {
      return mMonthCalendarItemsEventsFrameColorItem;
    }

    void setMonthCalendarItemsEventsIcon( const QString & v )
    {
      if (!isImmutable( QString::fromLatin1( "MonthCalendarItemsEventsIcon" ) ))
        mMonthCalendarItemsEventsIcon = v;
    }

    QString monthCalendarItemsEventsIcon() const
    {
      return mMonthCalendarItemsEventsIcon;
    }

    ItemString *monthCalendarItemsEventsIconItem()
    {
      return mMonthCalendarItemsEventsIconItem;
    }

    void setMonthCalendarItemsToDosBackgroundColor( const QColor & v )
    {
      if (!isImmutable( QString::fromLatin1( "MonthCalendarItemsToDosBackgroundColor" ) ))
        mMonthCalendarItemsToDosBackgroundColor = v;
    }

    QColor monthCalendarItemsToDosBackgroundColor() const
    {
      return mMonthCalendarItemsToDosBackgroundColor;
    }

    ItemColor *monthCalendarItemsToDosBackgroundColorItem()
    {
      return mMonthCalendarItemsToDosBackgroundColorItem;
    }

    void setMonthCalendarItemsToDosBackgroundImage( const QString & v )
    {
      if (!isImmutable( QString::fromLatin1( "MonthCalendarItemsToDosBackgroundImage" ) ))
        mMonthCalendarItemsToDosBackgroundImage = v;
    }

    QString monthCalendarItemsToDosBackgroundImage() const
    {
      return mMonthCalendarItemsToDosBackgroundImage;
    }

    ItemString *monthCalendarItemsToDosBackgroundImageItem()
    {
      return mMonthCalendarItemsToDosBackgroundImageItem;
    }

    void setMonthCalendarItemsToDosFont( const QFont & v )
    {
      if (!isImmutable( QString::fromLatin1( "MonthCalendarItemsToDosFont" ) ))
        mMonthCalendarItemsToDosFont = v;
    }

    QFont monthCalendarItemsToDosFont() const
    {
      return mMonthCalendarItemsToDosFont;
    }

    ItemFont *monthCalendarItemsToDosFontItem()
    {
      return mMonthCalendarItemsToDosFontItem;
    }

    void setMonthCalendarItemsToDosFrameColor( const QColor & v )
    {
      if (!isImmutable( QString::fromLatin1( "MonthCalendarItemsToDosFrameColor" ) ))
        mMonthCalendarItemsToDosFrameColor = v;
    }

    QColor monthCalendarItemsToDosFrameColor() const
    {
      return mMonthCalendarItemsToDosFrameColor;
    }

    ItemColor *monthCalendarItemsToDosFrameColorItem()
    {
      return mMonthCalendarItemsToDosFrameColorItem;
    }

    void setMonthCalendarItemsToDosIcon( const QString & v )
    {
      if (!isImmutable( QString::fromLatin1( "MonthCalendarItemsToDosIcon" ) ))
        mMonthCalendarItemsToDosIcon = v;
    }

    QString monthCalendarItemsToDosIcon() const
    {
      return mMonthCalendarItemsToDosIcon;
    }

    ItemString *monthCalendarItemsToDosIconItem()
    {
      return mMonthCalendarItemsToDosIconItem;
    }

    void setMonthCalendarItemsToDosDueTodayBackgroundColor( const QColor & v )
    {
      if (!isImmutable( QString::fromLatin1( "MonthCalendarItemsToDosDueTodayBackgroundColor" ) ))
        mMonthCalendarItemsToDosDueTodayBackgroundColor = v;
    }

    QColor monthCalendarItemsToDosDueTodayBackgroundColor() const
    {
      return mMonthCalendarItemsToDosDueTodayBackgroundColor;
    }

    ItemColor *monthCalendarItemsToDosDueTodayBackgroundColorItem()
    {
      return mMonthCalendarItemsToDosDueTodayBackgroundColorItem;
    }

    void setMonthCalendarItemsToDosDueTodayBackgroundImage( const QString & v )
    {
      if (!isImmutable( QString::fromLatin1( "MonthCalendarItemsToDosDueTodayBackgroundImage" ) ))
        mMonthCalendarItemsToDosDueTodayBackgroundImage = v;
    }

    QString monthCalendarItemsToDosDueTodayBackgroundImage() const
    {
      return mMonthCalendarItemsToDosDueTodayBackgroundImage;
    }

    ItemString *monthCalendarItemsToDosDueTodayBackgroundImageItem()
    {
      return mMonthCalendarItemsToDosDueTodayBackgroundImageItem;
    }

    void setMonthCalendarItemsToDosDueTodayFont( const QFont & v )
    {
      if (!isImmutable( QString::fromLatin1( "MonthCalendarItemsToDosDueTodayFont" ) ))
        mMonthCalendarItemsToDosDueTodayFont = v;
    }

    QFont monthCalendarItemsToDosDueTodayFont() const
    {
      return mMonthCalendarItemsToDosDueTodayFont;
    }

    ItemFont *monthCalendarItemsToDosDueTodayFontItem()
    {
      return mMonthCalendarItemsToDosDueTodayFontItem;
    }

    void setMonthCalendarItemsToDosDueTodayFrameColor( const QColor & v )
    {
      if (!isImmutable( QString::fromLatin1( "MonthCalendarItemsToDosDueTodayFrameColor" ) ))
        mMonthCalendarItemsToDosDueTodayFrameColor = v;
    }

    QColor monthCalendarItemsToDosDueTodayFrameColor() const
    {
      return mMonthCalendarItemsToDosDueTodayFrameColor;
    }

    ItemColor *monthCalendarItemsToDosDueTodayFrameColorItem()
    {
      return mMonthCalendarItemsToDosDueTodayFrameColorItem;
    }

    void setMonthCalendarItemsToDosDueTodayIcon( const QString & v )
    {
      if (!isImmutable( QString::fromLatin1( "MonthCalendarItemsToDosDueTodayIcon" ) ))
        mMonthCalendarItemsToDosDueTodayIcon = v;
    }

    QString monthCalendarItemsToDosDueTodayIcon() const
    {
      return mMonthCalendarItemsToDosDueTodayIcon;
    }

    ItemString *monthCalendarItemsToDosDueTodayIconItem()
    {
      return mMonthCalendarItemsToDosDueTodayIconItem;
    }

    void setMonthCalendarItemsToDosOverdueBackgroundColor( const QColor & v )
    {
      if (!isImmutable( QString::fromLatin1( "MonthCalendarItemsToDosOverdueBackgroundColor" ) ))
        mMonthCalendarItemsToDosOverdueBackgroundColor = v;
    }

    QColor monthCalendarItemsToDosOverdueBackgroundColor() const
    {
      return mMonthCalendarItemsToDosOverdueBackgroundColor;
    }

    ItemColor *monthCalendarItemsToDosOverdueBackgroundColorItem()
    {
      return mMonthCalendarItemsToDosOverdueBackgroundColorItem;
    }

    void setMonthCalendarItemsToDosOverdueBackgroundImage( const QString & v )
    {
      if (!isImmutable( QString::fromLatin1( "MonthCalendarItemsToDosOverdueBackgroundImage" ) ))
        mMonthCalendarItemsToDosOverdueBackgroundImage = v;
    }

    QString monthCalendarItemsToDosOverdueBackgroundImage() const
    {
      return mMonthCalendarItemsToDosOverdueBackgroundImage;
    }

    ItemString *monthCalendarItemsToDosOverdueBackgroundImageItem()
    {
      return mMonthCalendarItemsToDosOverdueBackgroundImageItem;
    }

    void setMonthCalendarItemsToDosOverdueFont( const QFont & v )
    {
      if (!isImmutable( QString::fromLatin1( "MonthCalendarItemsToDosOverdueFont" ) ))
        mMonthCalendarItemsToDosOverdueFont = v;
    }

    QFont monthCalendarItemsToDosOverdueFont() const
    {
      return mMonthCalendarItemsToDosOverdueFont;
    }

    ItemFont *monthCalendarItemsToDosOverdueFontItem()
    {
      return mMonthCalendarItemsToDosOverdueFontItem;
    }

    void setMonthCalendarItemsToDosOverdueFrameColor( const QColor & v )
    {
      if (!isImmutable( QString::fromLatin1( "MonthCalendarItemsToDosOverdueFrameColor" ) ))
        mMonthCalendarItemsToDosOverdueFrameColor = v;
    }

    QColor monthCalendarItemsToDosOverdueFrameColor() const
    {
      return mMonthCalendarItemsToDosOverdueFrameColor;
    }

    ItemColor *monthCalendarItemsToDosOverdueFrameColorItem()
    {
      return mMonthCalendarItemsToDosOverdueFrameColorItem;
    }

    void setMonthCalendarItemsToDosOverdueIcon( const QString & v )
    {
      if (!isImmutable( QString::fromLatin1( "MonthCalendarItemsToDosOverdueIcon" ) ))
        mMonthCalendarItemsToDosOverdueIcon = v;
    }

    QString monthCalendarItemsToDosOverdueIcon() const
    {
      return mMonthCalendarItemsToDosOverdueIcon;
    }

    ItemString *monthCalendarItemsToDosOverdueIconItem()
    {
      return mMonthCalendarItemsToDosOverdueIconItem;
    }

    void setMonthHolidaysBackgroundColor( const QColor & v )
    {
      if (!isImmutable( QString::fromLatin1( "MonthHolidaysBackgroundColor" ) ))
        mMonthHolidaysBackgroundColor = v;
    }

    QColor monthHolidaysBackgroundColor() const
    {
      return mMonthHolidaysBackgroundColor;
    }

    ItemColor *monthHolidaysBackgroundColorItem()
    {
      return mMonthHolidaysBackgroundColorItem;
    }

    void setMonthHolidaysBackgroundImage( const QString & v )
    {
      if (!isImmutable( QString::fromLatin1( "MonthHolidaysBackgroundImage" ) ))
        mMonthHolidaysBackgroundImage = v;
    }

    QString monthHolidaysBackgroundImage() const
    {
      return mMonthHolidaysBackgroundImage;
    }

    ItemString *monthHolidaysBackgroundImageItem()
    {
      return mMonthHolidaysBackgroundImageItem;
    }

  protected:
  public:

    // Save Settings
    bool mAutoExport;
    int mAutoExportInterval;
    bool mConfirm;
    int mDestination;

    // System Tray
    bool mShowReminderDaemon;

    // Time & Date
    QString mTimeZoneId;
    QDateTime mDayBegins;
    QString mHolidays;
    QDateTime mWorkingHoursStart;
    QDateTime mWorkingHoursEnd;
    bool mExcludeHolidays;
    bool mColorMonthBusyDaysEnabled;

    // General View
    bool mEnableToolTips;
    bool mTodosUseCategoryColors;
    int mNextXDays;
    bool mDailyRecur;
    bool mWeeklyRecur;
    bool mHighlightTodos;
    bool mHighlightJournals;
    bool mWeekNumbersShowWork;

    // Agenda View
    int mHourSize;
    bool mEnableAgendaItemIcons;
    bool mShowTodosAgendaView;
    bool mMarcusBainsEnabled;
    bool mMarcusBainsShowSeconds;
    bool mSelectionStartsEditor;
    int mAgendaViewColors;
    bool mColorBusyDaysEnabled;
    int mAgendaViewCalendarDisplay;

    // Month View
    bool mEnableMonthItemIcons;
    bool mShowTimeInMonthView;
    bool mShowTodosMonthView;
    bool mShowJournalsMonthView;
    bool mFullViewMonth;
    int mMonthViewColors;

    // Todo View
    bool mSortCompletedTodosSeparately;
    bool mFullViewTodo;
    bool mFlatListTodo;
    bool mRecordTodosInJournals;

    // Colors
    QColor mHolidayColor;
    QColor mAgendaBgColor;
    QColor mAgendaMarcusBainsLineLineColor;
    QColor mViewBgBusyColor;
    QColor mWorkingHoursColor;
    QColor mTodoDueTodayColor;
    QColor mTodoOverdueColor;

    // Fonts
    QFont mAgendaTimeLabelsFont;
    QFont mMonthViewFont;
    QFont mAgendaViewFont;
    QFont mAgendaMarcusBainsLineFont;

    // KOrganizer Plugins
    QStringList mSelectedPlugins;

    // Hidden Options
    bool mEnableQuickTodo;
    bool mEnableTodoQuickSearch;
    int mDefaultTodoAttachMethod;
    bool mCompactDialogs;
    bool mShowMenuBar;

    // Internal Settings
    int mWorkWeekMask;
    int mDefaultResourceColorSeed;
    QStringList mDefaultResourceColors;
    bool mAssignDefaultResourceColors;
    QStringList mDecorationsAtMonthViewTop;
    QStringList mDecorationsAtAgendaViewTop;
    QStringList mDecorationsAtAgendaViewBottom;

    // Theming
    QColor mAgendaGridBackgroundColor;
    QString mAgendaGridBackgroundImage;
    QColor mAgendaGridHighlightColor;
    QString mAgendaGridWorkHoursBackgroundImage;
    QColor mAgendaCalendarItemsBackgroundColor;
    QString mAgendaCalendarItemsBackgroundImage;
    QFont mAgendaCalendarItemsFont;
    QColor mAgendaCalendarItemsFrameColor;
    QString mAgendaCalendarItemsIcon;
    QString mAgendaCalendarItemsEventsBackgroundImage;
    QFont mAgendaCalendarItemsEventsFont;
    QColor mAgendaCalendarItemsEventsFrameColor;
    QString mAgendaCalendarItemsEventsIcon;
    QColor mAgendaCalendarItemsToDosBackgroundColor;
    QString mAgendaCalendarItemsToDosBackgroundImage;
    QFont mAgendaCalendarItemsToDosFont;
    QColor mAgendaCalendarItemsToDosFrameColor;
    QString mAgendaCalendarItemsToDosIcon;
    QString mAgendaCalendarItemsToDosDueTodayBackgroundImage;
    QFont mAgendaCalendarItemsToDosDueTodayFont;
    QColor mAgendaCalendarItemsToDosDueTodayFrameColor;
    QString mAgendaCalendarItemsToDosDueTodayIcon;
    QString mAgendaCalendarItemsToDosOverdueBackgroundImage;
    QFont mAgendaCalendarItemsToDosOverdueFont;
    QColor mAgendaCalendarItemsToDosOverdueFrameColor;
    QString mAgendaCalendarItemsToDosOverdueIcon;
    QColor mAgendaHolidaysBackgroundColor;
    QString mAgendaHolidaysBackgroundImage;

    // Theme/Month view
    QColor mMonthGridBackgroundColor;
    QString mMonthGridBackgroundImage;
    QColor mMonthGridHighlightColor;
    QColor mMonthGridWorkHoursBackgroundColor;
    QString mMonthGridWorkHoursBackgroundImage;
    QColor mMonthCalendarItemsBackgroundColor;
    QString mMonthCalendarItemsBackgroundImage;
    QFont mMonthCalendarItemsFont;
    QColor mMonthCalendarItemsFrameColor;
    QString mMonthCalendarItemsIcon;
    QColor mMonthCalendarItemsEventsBackgroundColor;
    QString mMonthCalendarItemsEventsBackgroundImage;
    QFont mMonthCalendarItemsEventsFont;
    QColor mMonthCalendarItemsEventsFrameColor;
    QString mMonthCalendarItemsEventsIcon;
    QColor mMonthCalendarItemsToDosBackgroundColor;
    QString mMonthCalendarItemsToDosBackgroundImage;
    QFont mMonthCalendarItemsToDosFont;
    QColor mMonthCalendarItemsToDosFrameColor;
    QString mMonthCalendarItemsToDosIcon;
    QColor mMonthCalendarItemsToDosDueTodayBackgroundColor;
    QString mMonthCalendarItemsToDosDueTodayBackgroundImage;
    QFont mMonthCalendarItemsToDosDueTodayFont;
    QColor mMonthCalendarItemsToDosDueTodayFrameColor;
    QString mMonthCalendarItemsToDosDueTodayIcon;
    QColor mMonthCalendarItemsToDosOverdueBackgroundColor;
    QString mMonthCalendarItemsToDosOverdueBackgroundImage;
    QFont mMonthCalendarItemsToDosOverdueFont;
    QColor mMonthCalendarItemsToDosOverdueFrameColor;
    QString mMonthCalendarItemsToDosOverdueIcon;
    QColor mMonthHolidaysBackgroundColor;
    QString mMonthHolidaysBackgroundImage;

  private:
    ItemBool *mAutoExportItem;
    ItemInt *mAutoExportIntervalItem;
    ItemBool *mConfirmItem;
    ItemEnum *mDestinationItem;
    ItemBool *mShowReminderDaemonItem;
    ItemString *mTimeZoneIdItem;
    ItemDateTime *mDayBeginsItem;
    ItemString *mHolidaysItem;
    ItemDateTime *mWorkingHoursStartItem;
    ItemDateTime *mWorkingHoursEndItem;
    ItemBool *mExcludeHolidaysItem;
    ItemBool *mColorMonthBusyDaysEnabledItem;
    ItemBool *mEnableToolTipsItem;
    ItemBool *mTodosUseCategoryColorsItem;
    ItemInt *mNextXDaysItem;
    ItemBool *mDailyRecurItem;
    ItemBool *mWeeklyRecurItem;
    ItemBool *mHighlightTodosItem;
    ItemBool *mHighlightJournalsItem;
    ItemBool *mWeekNumbersShowWorkItem;
    ItemInt *mHourSizeItem;
    ItemBool *mEnableAgendaItemIconsItem;
    ItemBool *mShowTodosAgendaViewItem;
    ItemBool *mMarcusBainsEnabledItem;
    ItemBool *mMarcusBainsShowSecondsItem;
    ItemBool *mSelectionStartsEditorItem;
    ItemEnum *mAgendaViewColorsItem;
    ItemBool *mColorBusyDaysEnabledItem;
    ItemEnum *mAgendaViewCalendarDisplayItem;
    ItemBool *mEnableMonthItemIconsItem;
    ItemBool *mShowTimeInMonthViewItem;
    ItemBool *mShowTodosMonthViewItem;
    ItemBool *mShowJournalsMonthViewItem;
    ItemBool *mFullViewMonthItem;
    ItemEnum *mMonthViewColorsItem;
    ItemBool *mSortCompletedTodosSeparatelyItem;
    ItemBool *mFullViewTodoItem;
    ItemBool *mFlatListTodoItem;
    ItemBool *mRecordTodosInJournalsItem;
    ItemColor *mHolidayColorItem;
    ItemColor *mAgendaBgColorItem;
    ItemColor *mAgendaMarcusBainsLineLineColorItem;
    ItemColor *mViewBgBusyColorItem;
    ItemColor *mWorkingHoursColorItem;
    ItemColor *mTodoDueTodayColorItem;
    ItemColor *mTodoOverdueColorItem;
    ItemFont *mAgendaTimeLabelsFontItem;
    ItemFont *mMonthViewFontItem;
    ItemFont *mAgendaViewFontItem;
    ItemFont *mAgendaMarcusBainsLineFontItem;
    ItemStringList *mSelectedPluginsItem;
    ItemBool *mEnableQuickTodoItem;
    ItemBool *mEnableTodoQuickSearchItem;
    ItemEnum *mDefaultTodoAttachMethodItem;
    ItemBool *mCompactDialogsItem;
    ItemBool *mShowMenuBarItem;
    ItemInt *mWorkWeekMaskItem;
    ItemInt *mDefaultResourceColorSeedItem;
    ItemStringList *mDefaultResourceColorsItem;
    ItemBool *mAssignDefaultResourceColorsItem;
    ItemStringList *mDecorationsAtMonthViewTopItem;
    ItemStringList *mDecorationsAtAgendaViewTopItem;
    ItemStringList *mDecorationsAtAgendaViewBottomItem;
    ItemColor *mAgendaGridBackgroundColorItem;
    ItemString *mAgendaGridBackgroundImageItem;
    ItemColor *mAgendaGridHighlightColorItem;
    ItemString *mAgendaGridWorkHoursBackgroundImageItem;
    ItemColor *mAgendaCalendarItemsBackgroundColorItem;
    ItemString *mAgendaCalendarItemsBackgroundImageItem;
    ItemFont *mAgendaCalendarItemsFontItem;
    ItemColor *mAgendaCalendarItemsFrameColorItem;
    ItemString *mAgendaCalendarItemsIconItem;
    ItemString *mAgendaCalendarItemsEventsBackgroundImageItem;
    ItemFont *mAgendaCalendarItemsEventsFontItem;
    ItemColor *mAgendaCalendarItemsEventsFrameColorItem;
    ItemString *mAgendaCalendarItemsEventsIconItem;
    ItemColor *mAgendaCalendarItemsToDosBackgroundColorItem;
    ItemString *mAgendaCalendarItemsToDosBackgroundImageItem;
    ItemFont *mAgendaCalendarItemsToDosFontItem;
    ItemColor *mAgendaCalendarItemsToDosFrameColorItem;
    ItemString *mAgendaCalendarItemsToDosIconItem;
    ItemString *mAgendaCalendarItemsToDosDueTodayBackgroundImageItem;
    ItemFont *mAgendaCalendarItemsToDosDueTodayFontItem;
    ItemColor *mAgendaCalendarItemsToDosDueTodayFrameColorItem;
    ItemString *mAgendaCalendarItemsToDosDueTodayIconItem;
    ItemString *mAgendaCalendarItemsToDosOverdueBackgroundImageItem;
    ItemFont *mAgendaCalendarItemsToDosOverdueFontItem;
    ItemColor *mAgendaCalendarItemsToDosOverdueFrameColorItem;
    ItemString *mAgendaCalendarItemsToDosOverdueIconItem;
    ItemColor *mAgendaHolidaysBackgroundColorItem;
    ItemString *mAgendaHolidaysBackgroundImageItem;
    ItemColor *mMonthGridBackgroundColorItem;
    ItemString *mMonthGridBackgroundImageItem;
    ItemColor *mMonthGridHighlightColorItem;
    ItemColor *mMonthGridWorkHoursBackgroundColorItem;
    ItemString *mMonthGridWorkHoursBackgroundImageItem;
    ItemColor *mMonthCalendarItemsBackgroundColorItem;
    ItemString *mMonthCalendarItemsBackgroundImageItem;
    ItemFont *mMonthCalendarItemsFontItem;
    ItemColor *mMonthCalendarItemsFrameColorItem;
    ItemString *mMonthCalendarItemsIconItem;
    ItemColor *mMonthCalendarItemsEventsBackgroundColorItem;
    ItemString *mMonthCalendarItemsEventsBackgroundImageItem;
    ItemFont *mMonthCalendarItemsEventsFontItem;
    ItemColor *mMonthCalendarItemsEventsFrameColorItem;
    ItemString *mMonthCalendarItemsEventsIconItem;
    ItemColor *mMonthCalendarItemsToDosBackgroundColorItem;
    ItemString *mMonthCalendarItemsToDosBackgroundImageItem;
    ItemFont *mMonthCalendarItemsToDosFontItem;
    ItemColor *mMonthCalendarItemsToDosFrameColorItem;
    ItemString *mMonthCalendarItemsToDosIconItem;
    ItemColor *mMonthCalendarItemsToDosDueTodayBackgroundColorItem;
    ItemString *mMonthCalendarItemsToDosDueTodayBackgroundImageItem;
    ItemFont *mMonthCalendarItemsToDosDueTodayFontItem;
    ItemColor *mMonthCalendarItemsToDosDueTodayFrameColorItem;
    ItemString *mMonthCalendarItemsToDosDueTodayIconItem;
    ItemColor *mMonthCalendarItemsToDosOverdueBackgroundColorItem;
    ItemString *mMonthCalendarItemsToDosOverdueBackgroundImageItem;
    ItemFont *mMonthCalendarItemsToDosOverdueFontItem;
    ItemColor *mMonthCalendarItemsToDosOverdueFrameColorItem;
    ItemString *mMonthCalendarItemsToDosOverdueIconItem;
    ItemColor *mMonthHolidaysBackgroundColorItem;
    ItemString *mMonthHolidaysBackgroundImageItem;
};

#endif