// This file is generated by kconfig_compiler_kf6 from kdenlivesettings.kcfg.
// All changes you do to this file will be lost.

#include "kdenlivesettings.h"

#include <qglobal.h>
#include <QFile>
#include <QQmlEngine>

class KdenliveSettingsHelper
{
  public:
    KdenliveSettingsHelper() : q(nullptr) {}
    ~KdenliveSettingsHelper() { delete q; q = nullptr; }
    KdenliveSettingsHelper(const KdenliveSettingsHelper&) = delete;
    KdenliveSettingsHelper& operator=(const KdenliveSettingsHelper&) = delete;
    KdenliveSettings *q;
};
Q_GLOBAL_STATIC(KdenliveSettingsHelper, s_globalKdenliveSettings)
KdenliveSettings *KdenliveSettings::self()
{
  if (!s_globalKdenliveSettings()->q) {
    new KdenliveSettings;
    s_globalKdenliveSettings()->q->read();
  }

  return s_globalKdenliveSettings()->q;
}

KdenliveSettings *KdenliveSettings::create(QQmlEngine *, QJSEngine *)
{
  QQmlEngine::setObjectOwnership(self(), QQmlEngine::CppOwnership);
  return self();
}

KdenliveSettings::KdenliveSettings( )
  : KConfigSkeleton()
{
  Q_ASSERT(!s_globalKdenliveSettings()->q);
  s_globalKdenliveSettings()->q = this;
  KConfigCompilerSignallingItem::NotifyFunction notifyFunction = static_cast<KConfigCompilerSignallingItem::NotifyFunction>(&KdenliveSettings::itemChanged);

  setCurrentGroup( QStringLiteral( "bin" ) );

  KConfigCompilerSignallingItem  *itemTreeviewheaders;
  KConfigSkeleton::ItemString  *innerItemTreeviewheaders;
  innerItemTreeviewheaders = new KConfigSkeleton::ItemString( currentGroup(), QStringLiteral( "treeviewheaders" ), mTreeviewheaders );
  itemTreeviewheaders = new KConfigCompilerSignallingItem(innerItemTreeviewheaders, this, notifyFunction, signalTreeviewheadersChanged);
  addItem( itemTreeviewheaders, QStringLiteral( "treeviewheaders" ) );
  KConfigCompilerSignallingItem  *itemBinSorting;
  KConfigSkeleton::ItemInt  *innerItemBinSorting;
  innerItemBinSorting = new KConfigSkeleton::ItemInt( currentGroup(), QStringLiteral( "binSorting" ), mBinSorting, 0 );
  itemBinSorting = new KConfigCompilerSignallingItem(innerItemBinSorting, this, notifyFunction, signalBinSortingChanged);
  addItem( itemBinSorting, QStringLiteral( "binSorting" ) );
  KConfigCompilerSignallingItem  *itemBinMode;
  KConfigSkeleton::ItemInt  *innerItemBinMode;
  innerItemBinMode = new KConfigSkeleton::ItemInt( currentGroup(), QStringLiteral( "binMode" ), mBinMode, 0 );
  itemBinMode = new KConfigCompilerSignallingItem(innerItemBinMode, this, notifyFunction, signalBinModeChanged);
  addItem( itemBinMode, QStringLiteral( "binMode" ) );
  KConfigCompilerSignallingItem  *itemBin_zoom;
  KConfigSkeleton::ItemInt  *innerItemBin_zoom;
  innerItemBin_zoom = new KConfigSkeleton::ItemInt( currentGroup(), QStringLiteral( "bin_zoom" ), mBin_zoom, 4 );
  itemBin_zoom = new KConfigCompilerSignallingItem(innerItemBin_zoom, this, notifyFunction, signalBin_zoomChanged);
  addItem( itemBin_zoom, QStringLiteral( "bin_zoom" ) );
  KConfigCompilerSignallingItem  *itemAddedExtensions;
  KConfigSkeleton::ItemString  *innerItemAddedExtensions;
  innerItemAddedExtensions = new KConfigSkeleton::ItemString( currentGroup(), QStringLiteral( "addedExtensions" ), mAddedExtensions );
  itemAddedExtensions = new KConfigCompilerSignallingItem(innerItemAddedExtensions, this, notifyFunction, signalAddedExtensionsChanged);
  addItem( itemAddedExtensions, QStringLiteral( "addedExtensions" ) );
  KConfigCompilerSignallingItem  *itemHoverPreview;
  KConfigSkeleton::ItemBool  *innerItemHoverPreview;
  innerItemHoverPreview = new KConfigSkeleton::ItemBool( currentGroup(), QStringLiteral( "hoverPreview" ), mHoverPreview, false );
  itemHoverPreview = new KConfigCompilerSignallingItem(innerItemHoverPreview, this, notifyFunction, signalHoverPreviewChanged);
  addItem( itemHoverPreview, QStringLiteral( "hoverPreview" ) );
  KConfigCompilerSignallingItem  *itemBinsCount;
  KConfigSkeleton::ItemInt  *innerItemBinsCount;
  innerItemBinsCount = new KConfigSkeleton::ItemInt( currentGroup(), QStringLiteral( "binsCount" ), mBinsCount, 1 );
  itemBinsCount = new KConfigCompilerSignallingItem(innerItemBinsCount, this, notifyFunction, signalBinsCountChanged);
  addItem( itemBinsCount, QStringLiteral( "binsCount" ) );

  setCurrentGroup( QStringLiteral( "jobs" ) );

  KConfigCompilerSignallingItem  *itemScenesplitthreshold;
  KConfigSkeleton::ItemInt  *innerItemScenesplitthreshold;
  innerItemScenesplitthreshold = new KConfigSkeleton::ItemInt( currentGroup(), QStringLiteral( "scenesplitthreshold" ), mScenesplitthreshold, 30 );
  itemScenesplitthreshold = new KConfigCompilerSignallingItem(innerItemScenesplitthreshold, this, notifyFunction, signalScenesplitthresholdChanged);
  addItem( itemScenesplitthreshold, QStringLiteral( "scenesplitthreshold" ) );
  KConfigCompilerSignallingItem  *itemScenesplitmarkers;
  KConfigSkeleton::ItemBool  *innerItemScenesplitmarkers;
  innerItemScenesplitmarkers = new KConfigSkeleton::ItemBool( currentGroup(), QStringLiteral( "scenesplitmarkers" ), mScenesplitmarkers, true );
  itemScenesplitmarkers = new KConfigCompilerSignallingItem(innerItemScenesplitmarkers, this, notifyFunction, signalScenesplitmarkersChanged);
  addItem( itemScenesplitmarkers, QStringLiteral( "scenesplitmarkers" ) );
  KConfigCompilerSignallingItem  *itemScenesplitrangemarkers;
  KConfigSkeleton::ItemBool  *innerItemScenesplitrangemarkers;
  innerItemScenesplitrangemarkers = new KConfigSkeleton::ItemBool( currentGroup(), QStringLiteral( "scenesplitrangemarkers" ), mScenesplitrangemarkers, true );
  itemScenesplitrangemarkers = new KConfigCompilerSignallingItem(innerItemScenesplitrangemarkers, this, notifyFunction, signalScenesplitrangemarkersChanged);
  addItem( itemScenesplitrangemarkers, QStringLiteral( "scenesplitrangemarkers" ) );
  KConfigCompilerSignallingItem  *itemScenesplitsubclips;
  KConfigSkeleton::ItemBool  *innerItemScenesplitsubclips;
  innerItemScenesplitsubclips = new KConfigSkeleton::ItemBool( currentGroup(), QStringLiteral( "scenesplitsubclips" ), mScenesplitsubclips, false );
  itemScenesplitsubclips = new KConfigCompilerSignallingItem(innerItemScenesplitsubclips, this, notifyFunction, signalScenesplitsubclipsChanged);
  addItem( itemScenesplitsubclips, QStringLiteral( "scenesplitsubclips" ) );

  setCurrentGroup( QStringLiteral( "misc" ) );

  KConfigCompilerSignallingItem  *itemCleanCacheMonths;
  KConfigSkeleton::ItemInt  *innerItemCleanCacheMonths;
  innerItemCleanCacheMonths = new KConfigSkeleton::ItemInt( currentGroup(), QStringLiteral( "cleanCacheMonths" ), mCleanCacheMonths, 6 );
  itemCleanCacheMonths = new KConfigCompilerSignallingItem(innerItemCleanCacheMonths, this, notifyFunction, signalCleanCacheMonthsChanged);
  addItem( itemCleanCacheMonths, QStringLiteral( "cleanCacheMonths" ) );
  KConfigCompilerSignallingItem  *itemOpenlastproject;
  KConfigSkeleton::ItemBool  *innerItemOpenlastproject;
  innerItemOpenlastproject = new KConfigSkeleton::ItemBool( currentGroup(), QStringLiteral( "openlastproject" ), mOpenlastproject, false );
  itemOpenlastproject = new KConfigCompilerSignallingItem(innerItemOpenlastproject, this, notifyFunction, signalOpenlastprojectChanged);
  addItem( itemOpenlastproject, QStringLiteral( "openlastproject" ) );
  KConfigCompilerSignallingItem  *itemCrashrecovery;
  KConfigSkeleton::ItemBool  *innerItemCrashrecovery;
  innerItemCrashrecovery = new KConfigSkeleton::ItemBool( currentGroup(), QStringLiteral( "crashrecovery" ), mCrashrecovery, true );
  itemCrashrecovery = new KConfigCompilerSignallingItem(innerItemCrashrecovery, this, notifyFunction, signalCrashrecoveryChanged);
  addItem( itemCrashrecovery, QStringLiteral( "crashrecovery" ) );
  KConfigCompilerSignallingItem  *itemAutosave_time;
  KConfigSkeleton::ItemInt  *innerItemAutosave_time;
  innerItemAutosave_time = new KConfigSkeleton::ItemInt( currentGroup(), QStringLiteral( "autosave_time" ), mAutosave_time, 60 );
  itemAutosave_time = new KConfigCompilerSignallingItem(innerItemAutosave_time, this, notifyFunction, signalAutosave_timeChanged);
  addItem( itemAutosave_time, QStringLiteral( "autosave_time" ) );
  KConfigCompilerSignallingItem  *itemAutosave_ops;
  KConfigSkeleton::ItemInt  *innerItemAutosave_ops;
  innerItemAutosave_ops = new KConfigSkeleton::ItemInt( currentGroup(), QStringLiteral( "autosave_ops" ), mAutosave_ops, 25 );
  itemAutosave_ops = new KConfigCompilerSignallingItem(innerItemAutosave_ops, this, notifyFunction, signalAutosave_opsChanged);
  addItem( itemAutosave_ops, QStringLiteral( "autosave_ops" ) );
  KConfigCompilerSignallingItem  *itemTabposition;
  KConfigSkeleton::ItemInt  *innerItemTabposition;
  innerItemTabposition = new KConfigSkeleton::ItemInt( currentGroup(), QStringLiteral( "tabposition" ), mTabposition, 1 );
  itemTabposition = new KConfigCompilerSignallingItem(innerItemTabposition, this, notifyFunction, signalTabpositionChanged);
  addItem( itemTabposition, QStringLiteral( "tabposition" ) );
  KConfigCompilerSignallingItem  *itemCheckfirstprojectclip;
  KConfigSkeleton::ItemBool  *innerItemCheckfirstprojectclip;
  innerItemCheckfirstprojectclip = new KConfigSkeleton::ItemBool( currentGroup(), QStringLiteral( "checkfirstprojectclip" ), mCheckfirstprojectclip, true );
  itemCheckfirstprojectclip = new KConfigCompilerSignallingItem(innerItemCheckfirstprojectclip, this, notifyFunction, signalCheckfirstprojectclipChanged);
  addItem( itemCheckfirstprojectclip, QStringLiteral( "checkfirstprojectclip" ) );
  KConfigCompilerSignallingItem  *itemKeep_original_frame_size;
  KConfigSkeleton::ItemBool  *innerItemKeep_original_frame_size;
  innerItemKeep_original_frame_size = new KConfigSkeleton::ItemBool( currentGroup(), QStringLiteral( "keep_original_frame_size" ), mKeep_original_frame_size, false );
  itemKeep_original_frame_size = new KConfigCompilerSignallingItem(innerItemKeep_original_frame_size, this, notifyFunction, signalKeep_original_frame_sizeChanged);
  addItem( itemKeep_original_frame_size, QStringLiteral( "keep_original_frame_size" ) );
  KConfigCompilerSignallingItem  *itemExportframe_usingsourceres;
  KConfigSkeleton::ItemBool  *innerItemExportframe_usingsourceres;
  innerItemExportframe_usingsourceres = new KConfigSkeleton::ItemBool( currentGroup(), QStringLiteral( "exportframe_usingsourceres" ), mExportframe_usingsourceres, true );
  itemExportframe_usingsourceres = new KConfigCompilerSignallingItem(innerItemExportframe_usingsourceres, this, notifyFunction, signalExportframe_usingsourceresChanged);
  addItem( itemExportframe_usingsourceres, QStringLiteral( "exportframe_usingsourceres" ) );
  KConfigCompilerSignallingItem  *itemColor_duration;
  KConfigSkeleton::ItemString  *innerItemColor_duration;
  innerItemColor_duration = new KConfigSkeleton::ItemString( currentGroup(), QStringLiteral( "color_duration" ), mColor_duration, QStringLiteral( "00:00:05:00" ) );
  itemColor_duration = new KConfigCompilerSignallingItem(innerItemColor_duration, this, notifyFunction, signalColor_durationChanged);
  addItem( itemColor_duration, QStringLiteral( "color_duration" ) );
  KConfigCompilerSignallingItem  *itemImage_duration;
  KConfigSkeleton::ItemString  *innerItemImage_duration;
  innerItemImage_duration = new KConfigSkeleton::ItemString( currentGroup(), QStringLiteral( "image_duration" ), mImage_duration, QStringLiteral( "00:00:05:00" ) );
  itemImage_duration = new KConfigCompilerSignallingItem(innerItemImage_duration, this, notifyFunction, signalImage_durationChanged);
  addItem( itemImage_duration, QStringLiteral( "image_duration" ) );
  KConfigCompilerSignallingItem  *itemSequence_duration;
  KConfigSkeleton::ItemString  *innerItemSequence_duration;
  innerItemSequence_duration = new KConfigSkeleton::ItemString( currentGroup(), QStringLiteral( "sequence_duration" ), mSequence_duration, QStringLiteral( "00:00:00:01" ) );
  itemSequence_duration = new KConfigCompilerSignallingItem(innerItemSequence_duration, this, notifyFunction, signalSequence_durationChanged);
  addItem( itemSequence_duration, QStringLiteral( "sequence_duration" ) );
  KConfigCompilerSignallingItem  *itemFade_duration;
  KConfigSkeleton::ItemString  *innerItemFade_duration;
  innerItemFade_duration = new KConfigSkeleton::ItemString( currentGroup(), QStringLiteral( "fade_duration" ), mFade_duration, QStringLiteral( "00:00:03:00" ) );
  itemFade_duration = new KConfigCompilerSignallingItem(innerItemFade_duration, this, notifyFunction, signalFade_durationChanged);
  addItem( itemFade_duration, QStringLiteral( "fade_duration" ) );
  KConfigCompilerSignallingItem  *itemMix_duration;
  KConfigSkeleton::ItemString  *innerItemMix_duration;
  innerItemMix_duration = new KConfigSkeleton::ItemString( currentGroup(), QStringLiteral( "mix_duration" ), mMix_duration, QStringLiteral( "00:00:01:00" ) );
  itemMix_duration = new KConfigCompilerSignallingItem(innerItemMix_duration, this, notifyFunction, signalMix_durationChanged);
  addItem( itemMix_duration, QStringLiteral( "mix_duration" ) );
  KConfigCompilerSignallingItem  *itemSubtitle_duration;
  KConfigSkeleton::ItemString  *innerItemSubtitle_duration;
  innerItemSubtitle_duration = new KConfigSkeleton::ItemString( currentGroup(), QStringLiteral( "subtitle_duration" ), mSubtitle_duration, QStringLiteral( "00:00:05:00" ) );
  itemSubtitle_duration = new KConfigCompilerSignallingItem(innerItemSubtitle_duration, this, notifyFunction, signalSubtitle_durationChanged);
  addItem( itemSubtitle_duration, QStringLiteral( "subtitle_duration" ) );
  KConfigCompilerSignallingItem  *itemAutoimagesequence;
  KConfigSkeleton::ItemBool  *innerItemAutoimagesequence;
  innerItemAutoimagesequence = new KConfigSkeleton::ItemBool( currentGroup(), QStringLiteral( "autoimagesequence" ), mAutoimagesequence, false );
  itemAutoimagesequence = new KConfigCompilerSignallingItem(innerItemAutoimagesequence, this, notifyFunction, signalAutoimagesequenceChanged);
  addItem( itemAutoimagesequence, QStringLiteral( "autoimagesequence" ) );
  KConfigCompilerSignallingItem  *itemIgnoresubdirstructure;
  KConfigSkeleton::ItemBool  *innerItemIgnoresubdirstructure;
  innerItemIgnoresubdirstructure = new KConfigSkeleton::ItemBool( currentGroup(), QStringLiteral( "ignoresubdirstructure" ), mIgnoresubdirstructure, false );
  itemIgnoresubdirstructure = new KConfigCompilerSignallingItem(innerItemIgnoresubdirstructure, this, notifyFunction, signalIgnoresubdirstructureChanged);
  addItem( itemIgnoresubdirstructure, QStringLiteral( "ignoresubdirstructure" ) );
  KConfigCompilerSignallingItem  *itemDisableimagescaling;
  KConfigSkeleton::ItemBool  *innerItemDisableimagescaling;
  innerItemDisableimagescaling = new KConfigSkeleton::ItemBool( currentGroup(), QStringLiteral( "disableimagescaling" ), mDisableimagescaling, false );
  itemDisableimagescaling = new KConfigCompilerSignallingItem(innerItemDisableimagescaling, this, notifyFunction, signalDisableimagescalingChanged);
  addItem( itemDisableimagescaling, QStringLiteral( "disableimagescaling" ) );
  KConfigCompilerSignallingItem  *itemAutomultistreams;
  KConfigSkeleton::ItemBool  *innerItemAutomultistreams;
  innerItemAutomultistreams = new KConfigSkeleton::ItemBool( currentGroup(), QStringLiteral( "automultistreams" ), mAutomultistreams, false );
  itemAutomultistreams = new KConfigCompilerSignallingItem(innerItemAutomultistreams, this, notifyFunction, signalAutomultistreamsChanged);
  addItem( itemAutomultistreams, QStringLiteral( "automultistreams" ) );
  KConfigCompilerSignallingItem  *itemUse_exiftool;
  KConfigSkeleton::ItemBool  *innerItemUse_exiftool;
  innerItemUse_exiftool = new KConfigSkeleton::ItemBool( currentGroup(), QStringLiteral( "use_exiftool" ), mUse_exiftool, false );
  itemUse_exiftool = new KConfigCompilerSignallingItem(innerItemUse_exiftool, this, notifyFunction, signalUse_exiftoolChanged);
  addItem( itemUse_exiftool, QStringLiteral( "use_exiftool" ) );
  KConfigCompilerSignallingItem  *itemUse_magicLantern;
  KConfigSkeleton::ItemBool  *innerItemUse_magicLantern;
  innerItemUse_magicLantern = new KConfigSkeleton::ItemBool( currentGroup(), QStringLiteral( "use_magicLantern" ), mUse_magicLantern, false );
  itemUse_magicLantern = new KConfigCompilerSignallingItem(innerItemUse_magicLantern, this, notifyFunction, signalUse_magicLanternChanged);
  addItem( itemUse_magicLantern, QStringLiteral( "use_magicLantern" ) );
  KConfigCompilerSignallingItem  *itemTitle_duration;
  KConfigSkeleton::ItemString  *innerItemTitle_duration;
  innerItemTitle_duration = new KConfigSkeleton::ItemString( currentGroup(), QStringLiteral( "title_duration" ), mTitle_duration, QStringLiteral( "00:00:05:00" ) );
  itemTitle_duration = new KConfigCompilerSignallingItem(innerItemTitle_duration, this, notifyFunction, signalTitle_durationChanged);
  addItem( itemTitle_duration, QStringLiteral( "title_duration" ) );
  KConfigCompilerSignallingItem  *itemTransition_duration;
  KConfigSkeleton::ItemString  *innerItemTransition_duration;
  innerItemTransition_duration = new KConfigSkeleton::ItemString( currentGroup(), QStringLiteral( "transition_duration" ), mTransition_duration, QStringLiteral( "00:00:03:00" ) );
  itemTransition_duration = new KConfigCompilerSignallingItem(innerItemTransition_duration, this, notifyFunction, signalTransition_durationChanged);
  addItem( itemTransition_duration, QStringLiteral( "transition_duration" ) );
  KConfigCompilerSignallingItem  *itemEnableAssetsIncludeList;
  KConfigSkeleton::ItemBool  *innerItemEnableAssetsIncludeList;
  innerItemEnableAssetsIncludeList = new KConfigSkeleton::ItemBool( currentGroup(), QStringLiteral( "enableAssetsIncludeList" ), mEnableAssetsIncludeList, false );
  itemEnableAssetsIncludeList = new KConfigCompilerSignallingItem(innerItemEnableAssetsIncludeList, this, notifyFunction, signalEnableAssetsIncludeListChanged);
  addItem( itemEnableAssetsIncludeList, QStringLiteral( "enableAssetsIncludeList" ) );
  KConfigCompilerSignallingItem  *itemEffectsInfoHeight;
  KConfigSkeleton::ItemString  *innerItemEffectsInfoHeight;
  innerItemEffectsInfoHeight = new KConfigSkeleton::ItemString( currentGroup(), QStringLiteral( "effectsInfoHeight" ), mEffectsInfoHeight );
  itemEffectsInfoHeight = new KConfigCompilerSignallingItem(innerItemEffectsInfoHeight, this, notifyFunction, signalEffectsInfoHeightChanged);
  addItem( itemEffectsInfoHeight, QStringLiteral( "effectsInfoHeight" ) );
  KConfigCompilerSignallingItem  *itemShowEffectsInfo;
  KConfigSkeleton::ItemBool  *innerItemShowEffectsInfo;
  innerItemShowEffectsInfo = new KConfigSkeleton::ItemBool( currentGroup(), QStringLiteral( "showEffectsInfo" ), mShowEffectsInfo, false );
  itemShowEffectsInfo = new KConfigCompilerSignallingItem(innerItemShowEffectsInfo, this, notifyFunction, signalShowEffectsInfoChanged);
  addItem( itemShowEffectsInfo, QStringLiteral( "showEffectsInfo" ) );
  KConfigCompilerSignallingItem  *itemTransitionsInfoHeight;
  KConfigSkeleton::ItemString  *innerItemTransitionsInfoHeight;
  innerItemTransitionsInfoHeight = new KConfigSkeleton::ItemString( currentGroup(), QStringLiteral( "transitionsInfoHeight" ), mTransitionsInfoHeight );
  itemTransitionsInfoHeight = new KConfigCompilerSignallingItem(innerItemTransitionsInfoHeight, this, notifyFunction, signalTransitionsInfoHeightChanged);
  addItem( itemTransitionsInfoHeight, QStringLiteral( "transitionsInfoHeight" ) );
  KConfigCompilerSignallingItem  *itemShowTransitionsInfo;
  KConfigSkeleton::ItemBool  *innerItemShowTransitionsInfo;
  innerItemShowTransitionsInfo = new KConfigSkeleton::ItemBool( currentGroup(), QStringLiteral( "showTransitionsInfo" ), mShowTransitionsInfo, false );
  itemShowTransitionsInfo = new KConfigCompilerSignallingItem(innerItemShowTransitionsInfo, this, notifyFunction, signalShowTransitionsInfoChanged);
  addItem( itemShowTransitionsInfo, QStringLiteral( "showTransitionsInfo" ) );
  KConfigCompilerSignallingItem  *itemDisable_effect_parameters;
  KConfigSkeleton::ItemBool  *innerItemDisable_effect_parameters;
  innerItemDisable_effect_parameters = new KConfigSkeleton::ItemBool( currentGroup(), QStringLiteral( "disable_effect_parameters" ), mDisable_effect_parameters, true );
  itemDisable_effect_parameters = new KConfigCompilerSignallingItem(innerItemDisable_effect_parameters, this, notifyFunction, signalDisable_effect_parametersChanged);
  addItem( itemDisable_effect_parameters, QStringLiteral( "disable_effect_parameters" ) );
  KConfigCompilerSignallingItem  *itemProfile_fps_filter;
  KConfigSkeleton::ItemString  *innerItemProfile_fps_filter;
  innerItemProfile_fps_filter = new KConfigSkeleton::ItemString( currentGroup(), QStringLiteral( "profile_fps_filter" ), mProfile_fps_filter );
  itemProfile_fps_filter = new KConfigCompilerSignallingItem(innerItemProfile_fps_filter, this, notifyFunction, signalProfile_fps_filterChanged);
  addItem( itemProfile_fps_filter, QStringLiteral( "profile_fps_filter" ) );
  KConfigCompilerSignallingItem  *itemProfile_scanning_filter;
  KConfigSkeleton::ItemString  *innerItemProfile_scanning_filter;
  innerItemProfile_scanning_filter = new KConfigSkeleton::ItemString( currentGroup(), QStringLiteral( "profile_scanning_filter" ), mProfile_scanning_filter );
  itemProfile_scanning_filter = new KConfigCompilerSignallingItem(innerItemProfile_scanning_filter, this, notifyFunction, signalProfile_scanning_filterChanged);
  addItem( itemProfile_scanning_filter, QStringLiteral( "profile_scanning_filter" ) );
  KConfigCompilerSignallingItem  *itemOpengl_backend;
  KConfigSkeleton::ItemInt  *innerItemOpengl_backend;
  innerItemOpengl_backend = new KConfigSkeleton::ItemInt( currentGroup(), QStringLiteral( "opengl_backend" ), mOpengl_backend, 16 );
  itemOpengl_backend = new KConfigCompilerSignallingItem(innerItemOpengl_backend, this, notifyFunction, signalOpengl_backendChanged);
  addItem( itemOpengl_backend, QStringLiteral( "opengl_backend" ) );

  setCurrentGroup( QStringLiteral( "project" ) );

  KConfigCompilerSignallingItem  *itemVideotracks;
  KConfigSkeleton::ItemInt  *innerItemVideotracks;
  innerItemVideotracks = new KConfigSkeleton::ItemInt( currentGroup(), QStringLiteral( "videotracks" ), mVideotracks, 2 );
  itemVideotracks = new KConfigCompilerSignallingItem(innerItemVideotracks, this, notifyFunction, signalVideotracksChanged);
  addItem( itemVideotracks, QStringLiteral( "videotracks" ) );
  KConfigCompilerSignallingItem  *itemAudiotracks;
  KConfigSkeleton::ItemInt  *innerItemAudiotracks;
  innerItemAudiotracks = new KConfigSkeleton::ItemInt( currentGroup(), QStringLiteral( "audiotracks" ), mAudiotracks, 2 );
  itemAudiotracks = new KConfigCompilerSignallingItem(innerItemAudiotracks, this, notifyFunction, signalAudiotracksChanged);
  addItem( itemAudiotracks, QStringLiteral( "audiotracks" ) );
  KConfigCompilerSignallingItem  *itemAudio_channels;
  KConfigSkeleton::ItemInt  *innerItemAudio_channels;
  innerItemAudio_channels = new KConfigSkeleton::ItemInt( currentGroup(), QStringLiteral( "audio_channels" ), mAudio_channels, 0 );
  itemAudio_channels = new KConfigCompilerSignallingItem(innerItemAudio_channels, this, notifyFunction, signalAudio_channelsChanged);
  addItem( itemAudio_channels, QStringLiteral( "audio_channels" ) );
  KConfigCompilerSignallingItem  *itemEnableproxy;
  KConfigSkeleton::ItemBool  *innerItemEnableproxy;
  innerItemEnableproxy = new KConfigSkeleton::ItemBool( currentGroup(), QStringLiteral( "enableproxy" ), mEnableproxy, false );
  itemEnableproxy = new KConfigCompilerSignallingItem(innerItemEnableproxy, this, notifyFunction, signalEnableproxyChanged);
  addItem( itemEnableproxy, QStringLiteral( "enableproxy" ) );
  KConfigCompilerSignallingItem  *itemExternalproxy;
  KConfigSkeleton::ItemBool  *innerItemExternalproxy;
  innerItemExternalproxy = new KConfigSkeleton::ItemBool( currentGroup(), QStringLiteral( "externalproxy" ), mExternalproxy, false );
  itemExternalproxy = new KConfigCompilerSignallingItem(innerItemExternalproxy, this, notifyFunction, signalExternalproxyChanged);
  addItem( itemExternalproxy, QStringLiteral( "externalproxy" ) );
  KConfigCompilerSignallingItem  *itemGenerateproxy;
  KConfigSkeleton::ItemBool  *innerItemGenerateproxy;
  innerItemGenerateproxy = new KConfigSkeleton::ItemBool( currentGroup(), QStringLiteral( "generateproxy" ), mGenerateproxy, false );
  itemGenerateproxy = new KConfigCompilerSignallingItem(innerItemGenerateproxy, this, notifyFunction, signalGenerateproxyChanged);
  addItem( itemGenerateproxy, QStringLiteral( "generateproxy" ) );
  KConfigCompilerSignallingItem  *itemExternal_proxy_profile;
  KConfigSkeleton::ItemInt  *innerItemExternal_proxy_profile;
  innerItemExternal_proxy_profile = new KConfigSkeleton::ItemInt( currentGroup(), QStringLiteral( "external_proxy_profile" ), mExternal_proxy_profile );
  itemExternal_proxy_profile = new KConfigCompilerSignallingItem(innerItemExternal_proxy_profile, this, notifyFunction, signalExternal_proxy_profileChanged);
  addItem( itemExternal_proxy_profile, QStringLiteral( "external_proxy_profile" ) );
  KConfigCompilerSignallingItem  *itemExternalProxyProfile;
  KConfigSkeleton::ItemString  *innerItemExternalProxyProfile;
  innerItemExternalProxyProfile = new KConfigSkeleton::ItemString( currentGroup(), QStringLiteral( "externalProxyProfile" ), mExternalProxyProfile );
  itemExternalProxyProfile = new KConfigCompilerSignallingItem(innerItemExternalProxyProfile, this, notifyFunction, signalExternalProxyProfileChanged);
  addItem( itemExternalProxyProfile, QStringLiteral( "externalProxyProfile" ) );
  KConfigCompilerSignallingItem  *itemGenerateimageproxy;
  KConfigSkeleton::ItemBool  *innerItemGenerateimageproxy;
  innerItemGenerateimageproxy = new KConfigSkeleton::ItemBool( currentGroup(), QStringLiteral( "generateimageproxy" ), mGenerateimageproxy, false );
  itemGenerateimageproxy = new KConfigCompilerSignallingItem(innerItemGenerateimageproxy, this, notifyFunction, signalGenerateimageproxyChanged);
  addItem( itemGenerateimageproxy, QStringLiteral( "generateimageproxy" ) );
  KConfigCompilerSignallingItem  *itemProxyminsize;
  KConfigSkeleton::ItemInt  *innerItemProxyminsize;
  innerItemProxyminsize = new KConfigSkeleton::ItemInt( currentGroup(), QStringLiteral( "proxyminsize" ), mProxyminsize, 1000 );
  itemProxyminsize = new KConfigCompilerSignallingItem(innerItemProxyminsize, this, notifyFunction, signalProxyminsizeChanged);
  addItem( itemProxyminsize, QStringLiteral( "proxyminsize" ) );
  KConfigCompilerSignallingItem  *itemProxyimageminsize;
  KConfigSkeleton::ItemInt  *innerItemProxyimageminsize;
  innerItemProxyimageminsize = new KConfigSkeleton::ItemInt( currentGroup(), QStringLiteral( "proxyimageminsize" ), mProxyimageminsize, 2000 );
  itemProxyimageminsize = new KConfigCompilerSignallingItem(innerItemProxyimageminsize, this, notifyFunction, signalProxyimageminsizeChanged);
  addItem( itemProxyimageminsize, QStringLiteral( "proxyimageminsize" ) );
  KConfigCompilerSignallingItem  *itemProxyimagesize;
  KConfigSkeleton::ItemInt  *innerItemProxyimagesize;
  innerItemProxyimagesize = new KConfigSkeleton::ItemInt( currentGroup(), QStringLiteral( "proxyimagesize" ), mProxyimagesize, 800 );
  itemProxyimagesize = new KConfigCompilerSignallingItem(innerItemProxyimagesize, this, notifyFunction, signalProxyimagesizeChanged);
  addItem( itemProxyimagesize, QStringLiteral( "proxyimagesize" ) );
  KConfigCompilerSignallingItem  *itemProxyscale;
  KConfigSkeleton::ItemInt  *innerItemProxyscale;
  innerItemProxyscale = new KConfigSkeleton::ItemInt( currentGroup(), QStringLiteral( "proxyscale" ), mProxyscale, 640 );
  itemProxyscale = new KConfigCompilerSignallingItem(innerItemProxyscale, this, notifyFunction, signalProxyscaleChanged);
  addItem( itemProxyscale, QStringLiteral( "proxyscale" ) );
  KConfigCompilerSignallingItem  *itemEnforceLowerTrackCompositing;
  KConfigSkeleton::ItemBool  *innerItemEnforceLowerTrackCompositing;
  innerItemEnforceLowerTrackCompositing = new KConfigSkeleton::ItemBool( currentGroup(), QStringLiteral( "enforceLowerTrackCompositing" ), mEnforceLowerTrackCompositing, false );
  itemEnforceLowerTrackCompositing = new KConfigCompilerSignallingItem(innerItemEnforceLowerTrackCompositing, this, notifyFunction, signalEnforceLowerTrackCompositingChanged);
  addItem( itemEnforceLowerTrackCompositing, QStringLiteral( "enforceLowerTrackCompositing" ) );
  KConfigCompilerSignallingItem  *itemProxyextension;
  KConfigSkeleton::ItemString  *innerItemProxyextension;
  innerItemProxyextension = new KConfigSkeleton::ItemString( currentGroup(), QStringLiteral( "proxyextension" ), mProxyextension );
  itemProxyextension = new KConfigCompilerSignallingItem(innerItemProxyextension, this, notifyFunction, signalProxyextensionChanged);
  addItem( itemProxyextension, QStringLiteral( "proxyextension" ) );
  KConfigCompilerSignallingItem  *itemProxyparams;
  KConfigSkeleton::ItemString  *innerItemProxyparams;
  innerItemProxyparams = new KConfigSkeleton::ItemString( currentGroup(), QStringLiteral( "proxyparams" ), mProxyparams );
  itemProxyparams = new KConfigCompilerSignallingItem(innerItemProxyparams, this, notifyFunction, signalProxyparamsChanged);
  addItem( itemProxyparams, QStringLiteral( "proxyparams" ) );
  KConfigCompilerSignallingItem  *itemProxy_profile;
  KConfigSkeleton::ItemInt  *innerItemProxy_profile;
  innerItemProxy_profile = new KConfigSkeleton::ItemInt( currentGroup(), QStringLiteral( "proxy_profile" ), mProxy_profile, 0 );
  itemProxy_profile = new KConfigCompilerSignallingItem(innerItemProxy_profile, this, notifyFunction, signalProxy_profileChanged);
  addItem( itemProxy_profile, QStringLiteral( "proxy_profile" ) );
  KConfigCompilerSignallingItem  *itemProxyalphaextension;
  KConfigSkeleton::ItemString  *innerItemProxyalphaextension;
  innerItemProxyalphaextension = new KConfigSkeleton::ItemString( currentGroup(), QStringLiteral( "proxyalphaextension" ), mProxyalphaextension );
  itemProxyalphaextension = new KConfigCompilerSignallingItem(innerItemProxyalphaextension, this, notifyFunction, signalProxyalphaextensionChanged);
  addItem( itemProxyalphaextension, QStringLiteral( "proxyalphaextension" ) );
  KConfigCompilerSignallingItem  *itemProxyalphaparams;
  KConfigSkeleton::ItemString  *innerItemProxyalphaparams;
  innerItemProxyalphaparams = new KConfigSkeleton::ItemString( currentGroup(), QStringLiteral( "proxyalphaparams" ), mProxyalphaparams );
  itemProxyalphaparams = new KConfigCompilerSignallingItem(innerItemProxyalphaparams, this, notifyFunction, signalProxyalphaparamsChanged);
  addItem( itemProxyalphaparams, QStringLiteral( "proxyalphaparams" ) );
  KConfigCompilerSignallingItem  *itemAlpha_profile;
  KConfigSkeleton::ItemInt  *innerItemAlpha_profile;
  innerItemAlpha_profile = new KConfigSkeleton::ItemInt( currentGroup(), QStringLiteral( "alpha_profile" ), mAlpha_profile, 0 );
  itemAlpha_profile = new KConfigCompilerSignallingItem(innerItemAlpha_profile, this, notifyFunction, signalAlpha_profileChanged);
  addItem( itemAlpha_profile, QStringLiteral( "alpha_profile" ) );
  KConfigCompilerSignallingItem  *itemTranscodeFriendly;
  KConfigSkeleton::ItemString  *innerItemTranscodeFriendly;
  innerItemTranscodeFriendly = new KConfigSkeleton::ItemString( currentGroup(), QStringLiteral( "transcodeFriendly" ), mTranscodeFriendly );
  itemTranscodeFriendly = new KConfigCompilerSignallingItem(innerItemTranscodeFriendly, this, notifyFunction, signalTranscodeFriendlyChanged);
  addItem( itemTranscodeFriendly, QStringLiteral( "transcodeFriendly" ) );
  KConfigCompilerSignallingItem  *itemTranscodingReplace;
  KConfigSkeleton::ItemBool  *innerItemTranscodingReplace;
  innerItemTranscodingReplace = new KConfigSkeleton::ItemBool( currentGroup(), QStringLiteral( "transcodingReplace" ), mTranscodingReplace, false );
  itemTranscodingReplace = new KConfigCompilerSignallingItem(innerItemTranscodingReplace, this, notifyFunction, signalTranscodingReplaceChanged);
  addItem( itemTranscodingReplace, QStringLiteral( "transcodingReplace" ) );
  KConfigCompilerSignallingItem  *itemPreviewextension;
  KConfigSkeleton::ItemString  *innerItemPreviewextension;
  innerItemPreviewextension = new KConfigSkeleton::ItemString( currentGroup(), QStringLiteral( "previewextension" ), mPreviewextension );
  itemPreviewextension = new KConfigCompilerSignallingItem(innerItemPreviewextension, this, notifyFunction, signalPreviewextensionChanged);
  addItem( itemPreviewextension, QStringLiteral( "previewextension" ) );
  KConfigCompilerSignallingItem  *itemPreview_profile;
  KConfigSkeleton::ItemInt  *innerItemPreview_profile;
  innerItemPreview_profile = new KConfigSkeleton::ItemInt( currentGroup(), QStringLiteral( "preview_profile" ), mPreview_profile, 0 );
  itemPreview_profile = new KConfigCompilerSignallingItem(innerItemPreview_profile, this, notifyFunction, signalPreview_profileChanged);
  addItem( itemPreview_profile, QStringLiteral( "preview_profile" ) );
  KConfigCompilerSignallingItem  *itemPreviewparams;
  KConfigSkeleton::ItemString  *innerItemPreviewparams;
  innerItemPreviewparams = new KConfigSkeleton::ItemString( currentGroup(), QStringLiteral( "previewparams" ), mPreviewparams );
  itemPreviewparams = new KConfigCompilerSignallingItem(innerItemPreviewparams, this, notifyFunction, signalPreviewparamsChanged);
  addItem( itemPreviewparams, QStringLiteral( "previewparams" ) );
  KConfigCompilerSignallingItem  *itemParallelrender;
  KConfigSkeleton::ItemBool  *innerItemParallelrender;
  innerItemParallelrender = new KConfigSkeleton::ItemBool( currentGroup(), QStringLiteral( "parallelrender" ), mParallelrender, false );
  itemParallelrender = new KConfigCompilerSignallingItem(innerItemParallelrender, this, notifyFunction, signalParallelrenderChanged);
  addItem( itemParallelrender, QStringLiteral( "parallelrender" ) );
  KConfigCompilerSignallingItem  *itemRenderInterp;
  KConfigSkeleton::ItemString  *innerItemRenderInterp;
  innerItemRenderInterp = new KConfigSkeleton::ItemString( currentGroup(), QStringLiteral( "renderInterp" ), mRenderInterp, QStringLiteral( "bilinear" ) );
  itemRenderInterp = new KConfigCompilerSignallingItem(innerItemRenderInterp, this, notifyFunction, signalRenderInterpChanged);
  addItem( itemRenderInterp, QStringLiteral( "renderInterp" ) );
  KConfigCompilerSignallingItem  *itemRenderDeinterlacer;
  KConfigSkeleton::ItemString  *innerItemRenderDeinterlacer;
  innerItemRenderDeinterlacer = new KConfigSkeleton::ItemString( currentGroup(), QStringLiteral( "renderDeinterlacer" ), mRenderDeinterlacer, QStringLiteral( "onefield" ) );
  itemRenderDeinterlacer = new KConfigCompilerSignallingItem(innerItemRenderDeinterlacer, this, notifyFunction, signalRenderDeinterlacerChanged);
  addItem( itemRenderDeinterlacer, QStringLiteral( "renderDeinterlacer" ) );
  KConfigCompilerSignallingItem  *itemVaapiEnabled;
  KConfigSkeleton::ItemBool  *innerItemVaapiEnabled;
  innerItemVaapiEnabled = new KConfigSkeleton::ItemBool( currentGroup(), QStringLiteral( "vaapiEnabled" ), mVaapiEnabled, false );
  itemVaapiEnabled = new KConfigCompilerSignallingItem(innerItemVaapiEnabled, this, notifyFunction, signalVaapiEnabledChanged);
  addItem( itemVaapiEnabled, QStringLiteral( "vaapiEnabled" ) );
  KConfigCompilerSignallingItem  *itemAmfEnabled;
  KConfigSkeleton::ItemBool  *innerItemAmfEnabled;
  innerItemAmfEnabled = new KConfigSkeleton::ItemBool( currentGroup(), QStringLiteral( "amfEnabled" ), mAmfEnabled, false );
  itemAmfEnabled = new KConfigCompilerSignallingItem(innerItemAmfEnabled, this, notifyFunction, signalAmfEnabledChanged);
  addItem( itemAmfEnabled, QStringLiteral( "amfEnabled" ) );
  KConfigCompilerSignallingItem  *itemSupportedHWCodecs;
  KConfigSkeleton::ItemStringList  *innerItemSupportedHWCodecs;
  innerItemSupportedHWCodecs = new KConfigSkeleton::ItemStringList( currentGroup(), QStringLiteral( "SupportedHWCodecs" ), mSupportedHWCodecs );
  itemSupportedHWCodecs = new KConfigCompilerSignallingItem(innerItemSupportedHWCodecs, this, notifyFunction, signalSupportedHWCodecsChanged);
  addItem( itemSupportedHWCodecs, QStringLiteral( "SupportedHWCodecs" ) );
  KConfigCompilerSignallingItem  *itemNvScalingEnabled;
  KConfigSkeleton::ItemBool  *innerItemNvScalingEnabled;
  innerItemNvScalingEnabled = new KConfigSkeleton::ItemBool( currentGroup(), QStringLiteral( "nvScalingEnabled" ), mNvScalingEnabled, false );
  itemNvScalingEnabled = new KConfigCompilerSignallingItem(innerItemNvScalingEnabled, this, notifyFunction, signalNvScalingEnabledChanged);
  addItem( itemNvScalingEnabled, QStringLiteral( "nvScalingEnabled" ) );
  KConfigCompilerSignallingItem  *itemHwDecoding;
  KConfigSkeleton::ItemString  *innerItemHwDecoding;
  innerItemHwDecoding = new KConfigSkeleton::ItemString( currentGroup(), QStringLiteral( "hwDecoding" ), mHwDecoding );
  itemHwDecoding = new KConfigCompilerSignallingItem(innerItemHwDecoding, this, notifyFunction, signalHwDecodingChanged);
  addItem( itemHwDecoding, QStringLiteral( "hwDecoding" ) );
  KConfigCompilerSignallingItem  *itemShowRenderTextParameters;
  KConfigSkeleton::ItemBool  *innerItemShowRenderTextParameters;
  innerItemShowRenderTextParameters = new KConfigSkeleton::ItemBool( currentGroup(), QStringLiteral( "showRenderTextParameters" ), mShowRenderTextParameters, false );
  itemShowRenderTextParameters = new KConfigCompilerSignallingItem(innerItemShowRenderTextParameters, this, notifyFunction, signalShowRenderTextParametersChanged);
  addItem( itemShowRenderTextParameters, QStringLiteral( "showRenderTextParameters" ) );

  setCurrentGroup( QStringLiteral( "timeline" ) );

  KConfigCompilerSignallingItem  *itemHeaderwidth;
  KConfigSkeleton::ItemInt  *innerItemHeaderwidth;
  innerItemHeaderwidth = new KConfigSkeleton::ItemInt( currentGroup(), QStringLiteral( "headerwidth" ), mHeaderwidth, 0 );
  itemHeaderwidth = new KConfigCompilerSignallingItem(innerItemHeaderwidth, this, notifyFunction, signalHeaderwidthChanged);
  addItem( itemHeaderwidth, QStringLiteral( "headerwidth" ) );
  KConfigCompilerSignallingItem  *itemDefaultkeyframeinterp;
  KConfigSkeleton::ItemInt  *innerItemDefaultkeyframeinterp;
  innerItemDefaultkeyframeinterp = new KConfigSkeleton::ItemInt( currentGroup(), QStringLiteral( "defaultkeyframeinterp" ), mDefaultkeyframeinterp, 1 );
  itemDefaultkeyframeinterp = new KConfigCompilerSignallingItem(innerItemDefaultkeyframeinterp, this, notifyFunction, signalDefaultkeyframeinterpChanged);
  addItem( itemDefaultkeyframeinterp, QStringLiteral( "defaultkeyframeinterp" ) );
  KConfigCompilerSignallingItem  *itemTimelinechunks;
  KConfigSkeleton::ItemInt  *innerItemTimelinechunks;
  innerItemTimelinechunks = new KConfigSkeleton::ItemInt( currentGroup(), QStringLiteral( "timelinechunks" ), mTimelinechunks, 25 );
  itemTimelinechunks = new KConfigCompilerSignallingItem(innerItemTimelinechunks, this, notifyFunction, signalTimelinechunksChanged);
  addItem( itemTimelinechunks, QStringLiteral( "timelinechunks" ) );
  KConfigCompilerSignallingItem  *itemAutopreview;
  KConfigSkeleton::ItemBool  *innerItemAutopreview;
  innerItemAutopreview = new KConfigSkeleton::ItemBool( currentGroup(), QStringLiteral( "autopreview" ), mAutopreview, false );
  itemAutopreview = new KConfigCompilerSignallingItem(innerItemAutopreview, this, notifyFunction, signalAutopreviewChanged);
  addItem( itemAutopreview, QStringLiteral( "autopreview" ) );
  KConfigCompilerSignallingItem  *itemDraginprogress;
  KConfigSkeleton::ItemBool  *innerItemDraginprogress;
  innerItemDraginprogress = new KConfigSkeleton::ItemBool( currentGroup(), QStringLiteral( "draginprogress" ), mDraginprogress, false );
  itemDraginprogress = new KConfigCompilerSignallingItem(innerItemDraginprogress, this, notifyFunction, signalDraginprogressChanged);
  addItem( itemDraginprogress, QStringLiteral( "draginprogress" ) );
  KConfigCompilerSignallingItem  *itemProxypreview;
  KConfigSkeleton::ItemBool  *innerItemProxypreview;
  innerItemProxypreview = new KConfigSkeleton::ItemBool( currentGroup(), QStringLiteral( "proxypreview" ), mProxypreview, true );
  itemProxypreview = new KConfigCompilerSignallingItem(innerItemProxypreview, this, notifyFunction, signalProxypreviewChanged);
  addItem( itemProxypreview, QStringLiteral( "proxypreview" ) );
  KConfigCompilerSignallingItem  *itemMultistream;
  KConfigSkeleton::ItemInt  *innerItemMultistream;
  innerItemMultistream = new KConfigSkeleton::ItemInt( currentGroup(), QStringLiteral( "multistream" ), mMultistream, 0 );
  itemMultistream = new KConfigCompilerSignallingItem(innerItemMultistream, this, notifyFunction, signalMultistreamChanged);
  addItem( itemMultistream, QStringLiteral( "multistream" ) );
  KConfigCompilerSignallingItem  *itemMultistream_checktrack;
  KConfigSkeleton::ItemBool  *innerItemMultistream_checktrack;
  innerItemMultistream_checktrack = new KConfigSkeleton::ItemBool( currentGroup(), QStringLiteral( "multistream_checktrack" ), mMultistream_checktrack, true );
  itemMultistream_checktrack = new KConfigCompilerSignallingItem(innerItemMultistream_checktrack, this, notifyFunction, signalMultistream_checktrackChanged);
  addItem( itemMultistream_checktrack, QStringLiteral( "multistream_checktrack" ) );
  KConfigCompilerSignallingItem  *itemVideothumbnails;
  KConfigSkeleton::ItemBool  *innerItemVideothumbnails;
  innerItemVideothumbnails = new KConfigSkeleton::ItemBool( currentGroup(), QStringLiteral( "videothumbnails" ), mVideothumbnails, true );
  itemVideothumbnails = new KConfigCompilerSignallingItem(innerItemVideothumbnails, this, notifyFunction, signalVideothumbnailsChanged);
  addItem( itemVideothumbnails, QStringLiteral( "videothumbnails" ) );
  KConfigCompilerSignallingItem  *itemAudiothumbnails;
  KConfigSkeleton::ItemBool  *innerItemAudiothumbnails;
  innerItemAudiothumbnails = new KConfigSkeleton::ItemBool( currentGroup(), QStringLiteral( "audiothumbnails" ), mAudiothumbnails, true );
  itemAudiothumbnails = new KConfigCompilerSignallingItem(innerItemAudiothumbnails, this, notifyFunction, signalAudiothumbnailsChanged);
  addItem( itemAudiothumbnails, QStringLiteral( "audiothumbnails" ) );
  KConfigCompilerSignallingItem  *itemWaveformScaler;
  KConfigSkeleton::ItemInt  *innerItemWaveformScaler;
  innerItemWaveformScaler = new KConfigSkeleton::ItemInt( currentGroup(), QStringLiteral( "waveformScaler" ), mWaveformScaler, 1 );
  itemWaveformScaler = new KConfigCompilerSignallingItem(innerItemWaveformScaler, this, notifyFunction, signalWaveformScalerChanged);
  addItem( itemWaveformScaler, QStringLiteral( "waveformScaler" ) );
  KConfigCompilerSignallingItem  *itemShowmarkers;
  KConfigSkeleton::ItemBool  *innerItemShowmarkers;
  innerItemShowmarkers = new KConfigSkeleton::ItemBool( currentGroup(), QStringLiteral( "showmarkers" ), mShowmarkers, true );
  itemShowmarkers = new KConfigCompilerSignallingItem(innerItemShowmarkers, this, notifyFunction, signalShowmarkersChanged);
  addItem( itemShowmarkers, QStringLiteral( "showmarkers" ) );
  KConfigCompilerSignallingItem  *itemDisplayallchannels;
  KConfigSkeleton::ItemBool  *innerItemDisplayallchannels;
  innerItemDisplayallchannels = new KConfigSkeleton::ItemBool( currentGroup(), QStringLiteral( "displayallchannels" ), mDisplayallchannels, true );
  itemDisplayallchannels = new KConfigCompilerSignallingItem(innerItemDisplayallchannels, this, notifyFunction, signalDisplayallchannelsChanged);
  addItem( itemDisplayallchannels, QStringLiteral( "displayallchannels" ) );
  KConfigCompilerSignallingItem  *itemNormalizechannels;
  KConfigSkeleton::ItemBool  *innerItemNormalizechannels;
  innerItemNormalizechannels = new KConfigSkeleton::ItemBool( currentGroup(), QStringLiteral( "normalizechannels" ), mNormalizechannels, true );
  itemNormalizechannels = new KConfigCompilerSignallingItem(innerItemNormalizechannels, this, notifyFunction, signalNormalizechannelsChanged);
  addItem( itemNormalizechannels, QStringLiteral( "normalizechannels" ) );
  KConfigCompilerSignallingItem  *itemAutotrackheight;
  KConfigSkeleton::ItemBool  *innerItemAutotrackheight;
  innerItemAutotrackheight = new KConfigSkeleton::ItemBool( currentGroup(), QStringLiteral( "autotrackheight" ), mAutotrackheight, false );
  itemAutotrackheight = new KConfigCompilerSignallingItem(innerItemAutotrackheight, this, notifyFunction, signalAutotrackheightChanged);
  addItem( itemAutotrackheight, QStringLiteral( "autotrackheight" ) );
  KConfigCompilerSignallingItem  *itemAutoscroll;
  KConfigSkeleton::ItemBool  *innerItemAutoscroll;
  innerItemAutoscroll = new KConfigSkeleton::ItemBool( currentGroup(), QStringLiteral( "autoscroll" ), mAutoscroll, true );
  itemAutoscroll = new KConfigCompilerSignallingItem(innerItemAutoscroll, this, notifyFunction, signalAutoscrollChanged);
  addItem( itemAutoscroll, QStringLiteral( "autoscroll" ) );
  KConfigCompilerSignallingItem  *itemCenteredplayhead;
  KConfigSkeleton::ItemBool  *innerItemCenteredplayhead;
  innerItemCenteredplayhead = new KConfigSkeleton::ItemBool( currentGroup(), QStringLiteral( "centeredplayhead" ), mCenteredplayhead, false );
  itemCenteredplayhead = new KConfigCompilerSignallingItem(innerItemCenteredplayhead, this, notifyFunction, signalCenteredplayheadChanged);
  addItem( itemCenteredplayhead, QStringLiteral( "centeredplayhead" ) );
  KConfigCompilerSignallingItem  *itemJumptostart;
  KConfigSkeleton::ItemBool  *innerItemJumptostart;
  innerItemJumptostart = new KConfigSkeleton::ItemBool( currentGroup(), QStringLiteral( "jumptostart" ), mJumptostart, false );
  itemJumptostart = new KConfigCompilerSignallingItem(innerItemJumptostart, this, notifyFunction, signalJumptostartChanged);
  addItem( itemJumptostart, QStringLiteral( "jumptostart" ) );
  KConfigCompilerSignallingItem  *itemPauseonseek;
  KConfigSkeleton::ItemBool  *innerItemPauseonseek;
  innerItemPauseonseek = new KConfigSkeleton::ItemBool( currentGroup(), QStringLiteral( "pauseonseek" ), mPauseonseek, true );
  itemPauseonseek = new KConfigCompilerSignallingItem(innerItemPauseonseek, this, notifyFunction, signalPauseonseekChanged);
  addItem( itemPauseonseek, QStringLiteral( "pauseonseek" ) );
  KConfigCompilerSignallingItem  *itemSeekonaddeffect;
  KConfigSkeleton::ItemBool  *innerItemSeekonaddeffect;
  innerItemSeekonaddeffect = new KConfigSkeleton::ItemBool( currentGroup(), QStringLiteral( "seekonaddeffect" ), mSeekonaddeffect, false );
  itemSeekonaddeffect = new KConfigCompilerSignallingItem(innerItemSeekonaddeffect, this, notifyFunction, signalSeekonaddeffectChanged);
  addItem( itemSeekonaddeffect, QStringLiteral( "seekonaddeffect" ) );
  KConfigCompilerSignallingItem  *itemEnableBuiltInEffects;
  KConfigSkeleton::ItemBool  *innerItemEnableBuiltInEffects;
  innerItemEnableBuiltInEffects = new KConfigSkeleton::ItemBool( currentGroup(), QStringLiteral( "enableBuiltInEffects" ), mEnableBuiltInEffects, false );
  itemEnableBuiltInEffects = new KConfigCompilerSignallingItem(innerItemEnableBuiltInEffects, this, notifyFunction, signalEnableBuiltInEffectsChanged);
  addItem( itemEnableBuiltInEffects, QStringLiteral( "enableBuiltInEffects" ) );
  KConfigCompilerSignallingItem  *itemTenbitpipeline;
  KConfigSkeleton::ItemBool  *innerItemTenbitpipeline;
  innerItemTenbitpipeline = new KConfigSkeleton::ItemBool( currentGroup(), QStringLiteral( "tenbitpipeline" ), mTenbitpipeline, false );
  itemTenbitpipeline = new KConfigCompilerSignallingItem(innerItemTenbitpipeline, this, notifyFunction, signalTenbitpipelineChanged);
  addItem( itemTenbitpipeline, QStringLiteral( "tenbitpipeline" ) );
  KConfigCompilerSignallingItem  *itemEffectsFilter;
  KConfigSkeleton::ItemBool  *innerItemEffectsFilter;
  innerItemEffectsFilter = new KConfigSkeleton::ItemBool( currentGroup(), QStringLiteral( "effectsFilter" ), mEffectsFilter, false );
  itemEffectsFilter = new KConfigCompilerSignallingItem(innerItemEffectsFilter, this, notifyFunction, signalEffectsFilterChanged);
  addItem( itemEffectsFilter, QStringLiteral( "effectsFilter" ) );
  KConfigCompilerSignallingItem  *itemTransitionsFilter;
  KConfigSkeleton::ItemBool  *innerItemTransitionsFilter;
  innerItemTransitionsFilter = new KConfigSkeleton::ItemBool( currentGroup(), QStringLiteral( "transitionsFilter" ), mTransitionsFilter, false );
  itemTransitionsFilter = new KConfigCompilerSignallingItem(innerItemTransitionsFilter, this, notifyFunction, signalTransitionsFilterChanged);
  addItem( itemTransitionsFilter, QStringLiteral( "transitionsFilter" ) );
  KConfigCompilerSignallingItem  *itemScrollvertically;
  KConfigSkeleton::ItemBool  *innerItemScrollvertically;
  innerItemScrollvertically = new KConfigSkeleton::ItemBool( currentGroup(), QStringLiteral( "scrollvertically" ), mScrollvertically, false );
  itemScrollvertically = new KConfigCompilerSignallingItem(innerItemScrollvertically, this, notifyFunction, signalScrollverticallyChanged);
  addItem( itemScrollvertically, QStringLiteral( "scrollvertically" ) );
  KConfigCompilerSignallingItem  *itemTrackheight;
  KConfigSkeleton::ItemInt  *innerItemTrackheight;
  innerItemTrackheight = new KConfigSkeleton::ItemInt( currentGroup(), QStringLiteral( "trackheight" ), mTrackheight, 0 );
  itemTrackheight = new KConfigCompilerSignallingItem(innerItemTrackheight, this, notifyFunction, signalTrackheightChanged);
  addItem( itemTrackheight, QStringLiteral( "trackheight" ) );
  KConfigCompilerSignallingItem  *itemAudiotracksbelow;
  KConfigSkeleton::ItemInt  *innerItemAudiotracksbelow;
  innerItemAudiotracksbelow = new KConfigSkeleton::ItemInt( currentGroup(), QStringLiteral( "audiotracksbelow" ), mAudiotracksbelow, 1 );
  itemAudiotracksbelow = new KConfigCompilerSignallingItem(innerItemAudiotracksbelow, this, notifyFunction, signalAudiotracksbelowChanged);
  addItem( itemAudiotracksbelow, QStringLiteral( "audiotracksbelow" ) );
  KConfigCompilerSignallingItem  *itemRaisepropsclips;
  KConfigSkeleton::ItemBool  *innerItemRaisepropsclips;
  innerItemRaisepropsclips = new KConfigSkeleton::ItemBool( currentGroup(), QStringLiteral( "raisepropsclips" ), mRaisepropsclips, true );
  itemRaisepropsclips = new KConfigCompilerSignallingItem(innerItemRaisepropsclips, this, notifyFunction, signalRaisepropsclipsChanged);
  addItem( itemRaisepropsclips, QStringLiteral( "raisepropsclips" ) );
  KConfigCompilerSignallingItem  *itemRaisepropscompositions;
  KConfigSkeleton::ItemBool  *innerItemRaisepropscompositions;
  innerItemRaisepropscompositions = new KConfigSkeleton::ItemBool( currentGroup(), QStringLiteral( "raisepropscompositions" ), mRaisepropscompositions, true );
  itemRaisepropscompositions = new KConfigCompilerSignallingItem(innerItemRaisepropscompositions, this, notifyFunction, signalRaisepropscompositionsChanged);
  addItem( itemRaisepropscompositions, QStringLiteral( "raisepropscompositions" ) );
  KConfigCompilerSignallingItem  *itemRaisepropsmixes;
  KConfigSkeleton::ItemBool  *innerItemRaisepropsmixes;
  innerItemRaisepropsmixes = new KConfigSkeleton::ItemBool( currentGroup(), QStringLiteral( "raisepropsmixes" ), mRaisepropsmixes, true );
  itemRaisepropsmixes = new KConfigCompilerSignallingItem(innerItemRaisepropsmixes, this, notifyFunction, signalRaisepropsmixesChanged);
  addItem( itemRaisepropsmixes, QStringLiteral( "raisepropsmixes" ) );
  KConfigCompilerSignallingItem  *itemRaisepropstracks;
  KConfigSkeleton::ItemBool  *innerItemRaisepropstracks;
  innerItemRaisepropstracks = new KConfigSkeleton::ItemBool( currentGroup(), QStringLiteral( "raisepropstracks" ), mRaisepropstracks, true );
  itemRaisepropstracks = new KConfigCompilerSignallingItem(innerItemRaisepropstracks, this, notifyFunction, signalRaisepropstracksChanged);
  addItem( itemRaisepropstracks, QStringLiteral( "raisepropstracks" ) );
  KConfigCompilerSignallingItem  *itemUiDebugMode;
  KConfigSkeleton::ItemBool  *innerItemUiDebugMode;
  innerItemUiDebugMode = new KConfigSkeleton::ItemBool( currentGroup(), QStringLiteral( "uiDebugMode" ), mUiDebugMode, false );
  itemUiDebugMode = new KConfigCompilerSignallingItem(innerItemUiDebugMode, this, notifyFunction, signalUiDebugModeChanged);
  addItem( itemUiDebugMode, QStringLiteral( "uiDebugMode" ) );

  setCurrentGroup( QStringLiteral( "sdl" ) );

  KConfigCompilerSignallingItem  *itemGpu_accel;
  KConfigSkeleton::ItemBool  *innerItemGpu_accel;
  innerItemGpu_accel = new KConfigSkeleton::ItemBool( currentGroup(), QStringLiteral( "gpu_accel" ), mGpu_accel, false );
  itemGpu_accel = new KConfigCompilerSignallingItem(innerItemGpu_accel, this, notifyFunction, signalGpu_accelChanged);
  addItem( itemGpu_accel, QStringLiteral( "gpu_accel" ) );
  KConfigCompilerSignallingItem  *itemAudio_scrub;
  KConfigSkeleton::ItemBool  *innerItemAudio_scrub;
  innerItemAudio_scrub = new KConfigSkeleton::ItemBool( currentGroup(), QStringLiteral( "audio_scrub" ), mAudio_scrub, true );
  itemAudio_scrub = new KConfigCompilerSignallingItem(innerItemAudio_scrub, this, notifyFunction, signalAudio_scrubChanged);
  addItem( itemAudio_scrub, QStringLiteral( "audio_scrub" ) );
  KConfigCompilerSignallingItem  *itemSdlAudioBackend;
  KConfigSkeleton::ItemString  *innerItemSdlAudioBackend;
  innerItemSdlAudioBackend = new KConfigSkeleton::ItemString( currentGroup(), QStringLiteral( "sdlAudioBackend" ), mSdlAudioBackend, QStringLiteral( "sdl2_audio" ) );
  itemSdlAudioBackend = new KConfigCompilerSignallingItem(innerItemSdlAudioBackend, this, notifyFunction, signalSdlAudioBackendChanged);
  addItem( itemSdlAudioBackend, QStringLiteral( "sdlAudioBackend" ) );
  KConfigCompilerSignallingItem  *itemAudio_backend;
  KConfigSkeleton::ItemInt  *innerItemAudio_backend;
  innerItemAudio_backend = new KConfigSkeleton::ItemInt( currentGroup(), QStringLiteral( "audio_backend" ), mAudio_backend, 0 );
  itemAudio_backend = new KConfigCompilerSignallingItem(innerItemAudio_backend, this, notifyFunction, signalAudio_backendChanged);
  addItem( itemAudio_backend, QStringLiteral( "audio_backend" ) );
  KConfigCompilerSignallingItem  *itemAudiobackend;
  KConfigSkeleton::ItemString  *innerItemAudiobackend;
  innerItemAudiobackend = new KConfigSkeleton::ItemString( currentGroup(), QStringLiteral( "audiobackend" ), mAudiobackend, QStringLiteral( "sdl2_audio" ) );
  itemAudiobackend = new KConfigCompilerSignallingItem(innerItemAudiobackend, this, notifyFunction, signalAudiobackendChanged);
  addItem( itemAudiobackend, QStringLiteral( "audiobackend" ) );
  KConfigCompilerSignallingItem  *itemAudio_driver;
  KConfigSkeleton::ItemUInt  *innerItemAudio_driver;
  innerItemAudio_driver = new KConfigSkeleton::ItemUInt( currentGroup(), QStringLiteral( "audio_driver" ), mAudio_driver, 0 );
  itemAudio_driver = new KConfigCompilerSignallingItem(innerItemAudio_driver, this, notifyFunction, signalAudio_driverChanged);
  addItem( itemAudio_driver, QStringLiteral( "audio_driver" ) );
  KConfigCompilerSignallingItem  *itemAudiodevicename;
  KConfigSkeleton::ItemString  *innerItemAudiodevicename;
  innerItemAudiodevicename = new KConfigSkeleton::ItemString( currentGroup(), QStringLiteral( "audiodevicename" ), mAudiodevicename );
  itemAudiodevicename = new KConfigCompilerSignallingItem(innerItemAudiodevicename, this, notifyFunction, signalAudiodevicenameChanged);
  addItem( itemAudiodevicename, QStringLiteral( "audiodevicename" ) );
  KConfigCompilerSignallingItem  *itemAudiodrivername;
  KConfigSkeleton::ItemString  *innerItemAudiodrivername;
  innerItemAudiodrivername = new KConfigSkeleton::ItemString( currentGroup(), QStringLiteral( "audiodrivername" ), mAudiodrivername );
  itemAudiodrivername = new KConfigCompilerSignallingItem(innerItemAudiodrivername, this, notifyFunction, signalAudiodrivernameChanged);
  addItem( itemAudiodrivername, QStringLiteral( "audiodrivername" ) );
  KConfigCompilerSignallingItem  *itemDisablereccountdown;
  KConfigSkeleton::ItemBool  *innerItemDisablereccountdown;
  innerItemDisablereccountdown = new KConfigSkeleton::ItemBool( currentGroup(), QStringLiteral( "disablereccountdown" ), mDisablereccountdown, false );
  itemDisablereccountdown = new KConfigCompilerSignallingItem(innerItemDisablereccountdown, this, notifyFunction, signalDisablereccountdownChanged);
  addItem( itemDisablereccountdown, QStringLiteral( "disablereccountdown" ) );
  KConfigCompilerSignallingItem  *itemVideodrivername;
  KConfigSkeleton::ItemString  *innerItemVideodrivername;
  innerItemVideodrivername = new KConfigSkeleton::ItemString( currentGroup(), QStringLiteral( "videodrivername" ), mVideodrivername );
  itemVideodrivername = new KConfigCompilerSignallingItem(innerItemVideodrivername, this, notifyFunction, signalVideodrivernameChanged);
  addItem( itemVideodrivername, QStringLiteral( "videodrivername" ) );
  KConfigCompilerSignallingItem  *itemAudio_device;
  KConfigSkeleton::ItemInt  *innerItemAudio_device;
  innerItemAudio_device = new KConfigSkeleton::ItemInt( currentGroup(), QStringLiteral( "audio_device" ), mAudio_device );
  itemAudio_device = new KConfigCompilerSignallingItem(innerItemAudio_device, this, notifyFunction, signalAudio_deviceChanged);
  addItem( itemAudio_device, QStringLiteral( "audio_device" ) );
  KConfigCompilerSignallingItem  *itemWindow_background;
  KConfigSkeleton::ItemColor  *innerItemWindow_background;
  innerItemWindow_background = new KConfigSkeleton::ItemColor( currentGroup(), QStringLiteral( "window_background" ), mWindow_background, QColor( "#535353" ) );
  itemWindow_background = new KConfigCompilerSignallingItem(innerItemWindow_background, this, notifyFunction, signalWindow_backgroundChanged);
  addItem( itemWindow_background, QStringLiteral( "window_background" ) );
  KConfigCompilerSignallingItem  *itemShowMonitorGrid;
  KConfigSkeleton::ItemBool  *innerItemShowMonitorGrid;
  innerItemShowMonitorGrid = new KConfigSkeleton::ItemBool( currentGroup(), QStringLiteral( "showMonitorGrid" ), mShowMonitorGrid, false );
  itemShowMonitorGrid = new KConfigCompilerSignallingItem(innerItemShowMonitorGrid, this, notifyFunction, signalShowMonitorGridChanged);
  addItem( itemShowMonitorGrid, QStringLiteral( "showMonitorGrid" ) );
  KConfigCompilerSignallingItem  *itemMonitorGridH;
  KConfigSkeleton::ItemInt  *innerItemMonitorGridH;
  innerItemMonitorGridH = new KConfigSkeleton::ItemInt( currentGroup(), QStringLiteral( "monitorGridH" ), mMonitorGridH, 100 );
  itemMonitorGridH = new KConfigCompilerSignallingItem(innerItemMonitorGridH, this, notifyFunction, signalMonitorGridHChanged);
  addItem( itemMonitorGridH, QStringLiteral( "monitorGridH" ) );
  KConfigCompilerSignallingItem  *itemMonitorGridV;
  KConfigSkeleton::ItemInt  *innerItemMonitorGridV;
  innerItemMonitorGridV = new KConfigSkeleton::ItemInt( currentGroup(), QStringLiteral( "monitorGridV" ), mMonitorGridV, 100 );
  itemMonitorGridV = new KConfigCompilerSignallingItem(innerItemMonitorGridV, this, notifyFunction, signalMonitorGridVChanged);
  addItem( itemMonitorGridV, QStringLiteral( "monitorGridV" ) );
  KConfigCompilerSignallingItem  *itemMonitor_background;
  KConfigSkeleton::ItemString  *innerItemMonitor_background;
  innerItemMonitor_background = new KConfigSkeleton::ItemString( currentGroup(), QStringLiteral( "monitor_background" ), mMonitor_background, QStringLiteral( "black" ) );
  itemMonitor_background = new KConfigCompilerSignallingItem(innerItemMonitor_background, this, notifyFunction, signalMonitor_backgroundChanged);
  addItem( itemMonitor_background, QStringLiteral( "monitor_background" ) );
  KConfigCompilerSignallingItem  *itemMonitor_progressive;
  KConfigSkeleton::ItemBool  *innerItemMonitor_progressive;
  innerItemMonitor_progressive = new KConfigSkeleton::ItemBool( currentGroup(), QStringLiteral( "monitor_progressive" ), mMonitor_progressive, true );
  itemMonitor_progressive = new KConfigCompilerSignallingItem(innerItemMonitor_progressive, this, notifyFunction, signalMonitor_progressiveChanged);
  addItem( itemMonitor_progressive, QStringLiteral( "monitor_progressive" ) );
  KConfigCompilerSignallingItem  *itemVolume;
  KConfigSkeleton::ItemInt  *innerItemVolume;
  innerItemVolume = new KConfigSkeleton::ItemInt( currentGroup(), QStringLiteral( "volume" ), mVolume, 100 );
  itemVolume = new KConfigCompilerSignallingItem(innerItemVolume, this, notifyFunction, signalVolumeChanged);
  addItem( itemVolume, QStringLiteral( "volume" ) );
  KConfigCompilerSignallingItem  *itemMonitor_dropframes;
  KConfigSkeleton::ItemBool  *innerItemMonitor_dropframes;
  innerItemMonitor_dropframes = new KConfigSkeleton::ItemBool( currentGroup(), QStringLiteral( "monitor_dropframes" ), mMonitor_dropframes, true );
  itemMonitor_dropframes = new KConfigCompilerSignallingItem(innerItemMonitor_dropframes, this, notifyFunction, signalMonitor_dropframesChanged);
  addItem( itemMonitor_dropframes, QStringLiteral( "monitor_dropframes" ) );
  KConfigCompilerSignallingItem  *itemExternal_display;
  KConfigSkeleton::ItemBool  *innerItemExternal_display;
  innerItemExternal_display = new KConfigSkeleton::ItemBool( currentGroup(), QStringLiteral( "external_display" ), mExternal_display, false );
  itemExternal_display = new KConfigCompilerSignallingItem(innerItemExternal_display, this, notifyFunction, signalExternal_displayChanged);
  addItem( itemExternal_display, QStringLiteral( "external_display" ) );
  KConfigCompilerSignallingItem  *itemBlackmagic_output_device;
  KConfigSkeleton::ItemInt  *innerItemBlackmagic_output_device;
  innerItemBlackmagic_output_device = new KConfigSkeleton::ItemInt( currentGroup(), QStringLiteral( "blackmagic_output_device" ), mBlackmagic_output_device, 0 );
  itemBlackmagic_output_device = new KConfigCompilerSignallingItem(innerItemBlackmagic_output_device, this, notifyFunction, signalBlackmagic_output_deviceChanged);
  addItem( itemBlackmagic_output_device, QStringLiteral( "blackmagic_output_device" ) );
  KConfigCompilerSignallingItem  *itemPlay_monitor_on_click;
  KConfigSkeleton::ItemBool  *innerItemPlay_monitor_on_click;
  innerItemPlay_monitor_on_click = new KConfigSkeleton::ItemBool( currentGroup(), QStringLiteral( "play_monitor_on_click" ), mPlay_monitor_on_click, true );
  itemPlay_monitor_on_click = new KConfigCompilerSignallingItem(innerItemPlay_monitor_on_click, this, notifyFunction, signalPlay_monitor_on_clickChanged);
  addItem( itemPlay_monitor_on_click, QStringLiteral( "play_monitor_on_click" ) );
  KConfigCompilerSignallingItem  *itemMirrorMonitorOnFullscreen;
  KConfigSkeleton::ItemBool  *innerItemMirrorMonitorOnFullscreen;
  innerItemMirrorMonitorOnFullscreen = new KConfigSkeleton::ItemBool( currentGroup(), QStringLiteral( "mirrorMonitorOnFullscreen" ), mMirrorMonitorOnFullscreen, false );
  itemMirrorMonitorOnFullscreen = new KConfigCompilerSignallingItem(innerItemMirrorMonitorOnFullscreen, this, notifyFunction, signalMirrorMonitorOnFullscreenChanged);
  addItem( itemMirrorMonitorOnFullscreen, QStringLiteral( "mirrorMonitorOnFullscreen" ) );
  KConfigCompilerSignallingItem  *itemFullscreen_monitor;
  KConfigSkeleton::ItemString  *innerItemFullscreen_monitor;
  innerItemFullscreen_monitor = new KConfigSkeleton::ItemString( currentGroup(), QStringLiteral( "fullscreen_monitor" ), mFullscreen_monitor );
  itemFullscreen_monitor = new KConfigCompilerSignallingItem(innerItemFullscreen_monitor, this, notifyFunction, signalFullscreen_monitorChanged);
  addItem( itemFullscreen_monitor, QStringLiteral( "fullscreen_monitor" ) );
  KConfigCompilerSignallingItem  *itemProject_monitor_fullscreen;
  KConfigSkeleton::ItemString  *innerItemProject_monitor_fullscreen;
  innerItemProject_monitor_fullscreen = new KConfigSkeleton::ItemString( currentGroup(), QStringLiteral( "project_monitor_fullscreen" ), mProject_monitor_fullscreen );
  itemProject_monitor_fullscreen = new KConfigCompilerSignallingItem(innerItemProject_monitor_fullscreen, this, notifyFunction, signalProject_monitor_fullscreenChanged);
  addItem( itemProject_monitor_fullscreen, QStringLiteral( "project_monitor_fullscreen" ) );
  KConfigCompilerSignallingItem  *itemClip_monitor_fullscreen;
  KConfigSkeleton::ItemString  *innerItemClip_monitor_fullscreen;
  innerItemClip_monitor_fullscreen = new KConfigSkeleton::ItemString( currentGroup(), QStringLiteral( "clip_monitor_fullscreen" ), mClip_monitor_fullscreen );
  itemClip_monitor_fullscreen = new KConfigCompilerSignallingItem(innerItemClip_monitor_fullscreen, this, notifyFunction, signalClip_monitor_fullscreenChanged);
  addItem( itemClip_monitor_fullscreen, QStringLiteral( "clip_monitor_fullscreen" ) );
  KConfigCompilerSignallingItem  *itemPreferredcomposite;
  KConfigSkeleton::ItemString  *innerItemPreferredcomposite;
  innerItemPreferredcomposite = new KConfigSkeleton::ItemString( currentGroup(), QStringLiteral( "preferredcomposite" ), mPreferredcomposite );
  itemPreferredcomposite = new KConfigCompilerSignallingItem(innerItemPreferredcomposite, this, notifyFunction, signalPreferredcompositeChanged);
  addItem( itemPreferredcomposite, QStringLiteral( "preferredcomposite" ) );
  QStringList defaultcompositingList;
  defaultcompositingList.append( QString::fromUtf8( "qtblend" ) );
  defaultcompositingList.append( QString::fromUtf8( "frei0r.cairoblend" ) );

  KConfigCompilerSignallingItem  *itemCompositingList;
  KConfigSkeleton::ItemStringList  *innerItemCompositingList;
  innerItemCompositingList = new KConfigSkeleton::ItemStringList( currentGroup(), QStringLiteral( "compositingList" ), mCompositingList, defaultcompositingList );
  itemCompositingList = new KConfigCompilerSignallingItem(innerItemCompositingList, this, notifyFunction, signalCompositingListChanged);
  addItem( itemCompositingList, QStringLiteral( "compositingList" ) );

  setCurrentGroup( QStringLiteral( "tools" ) );

  KConfigCompilerSignallingItem  *itemSubtitle_razor_mode;
  KConfigSkeleton::ItemInt  *innerItemSubtitle_razor_mode;
  innerItemSubtitle_razor_mode = new KConfigSkeleton::ItemInt( currentGroup(), QStringLiteral( "subtitle_razor_mode" ), mSubtitle_razor_mode, 0 );
  itemSubtitle_razor_mode = new KConfigCompilerSignallingItem(innerItemSubtitle_razor_mode, this, notifyFunction, signalSubtitle_razor_modeChanged);
  addItem( itemSubtitle_razor_mode, QStringLiteral( "subtitle_razor_mode" ) );

  setCurrentGroup( QStringLiteral( "env" ) );

  KConfigCompilerSignallingItem  *itemMltpath;
  KConfigSkeleton::ItemPath  *innerItemMltpath;
  innerItemMltpath = new KConfigSkeleton::ItemPath( currentGroup(), QStringLiteral( "mltpath" ), mMltpath );
  itemMltpath = new KConfigCompilerSignallingItem(innerItemMltpath, this, notifyFunction, signalMltpathChanged);
  addItem( itemMltpath, QStringLiteral( "mltpath" ) );
  KConfigCompilerSignallingItem  *itemKdenliverendererpath;
  KConfigSkeleton::ItemPath  *innerItemKdenliverendererpath;
  innerItemKdenliverendererpath = new KConfigSkeleton::ItemPath( currentGroup(), QStringLiteral( "kdenliverendererpath" ), mKdenliverendererpath );
  itemKdenliverendererpath = new KConfigCompilerSignallingItem(innerItemKdenliverendererpath, this, notifyFunction, signalKdenliverendererpathChanged);
  addItem( itemKdenliverendererpath, QStringLiteral( "kdenliverendererpath" ) );
  KConfigCompilerSignallingItem  *itemMeltpath;
  KConfigSkeleton::ItemPath  *innerItemMeltpath;
  innerItemMeltpath = new KConfigSkeleton::ItemPath( currentGroup(), QStringLiteral( "meltpath" ), mMeltpath );
  itemMeltpath = new KConfigCompilerSignallingItem(innerItemMeltpath, this, notifyFunction, signalMeltpathChanged);
  addItem( itemMeltpath, QStringLiteral( "meltpath" ) );
  KConfigCompilerSignallingItem  *itemFfmpegpath;
  KConfigSkeleton::ItemPath  *innerItemFfmpegpath;
  innerItemFfmpegpath = new KConfigSkeleton::ItemPath( currentGroup(), QStringLiteral( "ffmpegpath" ), mFfmpegpath );
  itemFfmpegpath = new KConfigCompilerSignallingItem(innerItemFfmpegpath, this, notifyFunction, signalFfmpegpathChanged);
  addItem( itemFfmpegpath, QStringLiteral( "ffmpegpath" ) );
  KConfigCompilerSignallingItem  *itemFfplaypath;
  KConfigSkeleton::ItemPath  *innerItemFfplaypath;
  innerItemFfplaypath = new KConfigSkeleton::ItemPath( currentGroup(), QStringLiteral( "ffplaypath" ), mFfplaypath );
  itemFfplaypath = new KConfigCompilerSignallingItem(innerItemFfplaypath, this, notifyFunction, signalFfplaypathChanged);
  addItem( itemFfplaypath, QStringLiteral( "ffplaypath" ) );
  KConfigCompilerSignallingItem  *itemFfprobepath;
  KConfigSkeleton::ItemPath  *innerItemFfprobepath;
  innerItemFfprobepath = new KConfigSkeleton::ItemPath( currentGroup(), QStringLiteral( "ffprobepath" ), mFfprobepath );
  itemFfprobepath = new KConfigCompilerSignallingItem(innerItemFfprobepath, this, notifyFunction, signalFfprobepathChanged);
  addItem( itemFfprobepath, QStringLiteral( "ffprobepath" ) );
  KConfigCompilerSignallingItem  *itemProcessingthreads;
  KConfigSkeleton::ItemInt  *innerItemProcessingthreads;
  innerItemProcessingthreads = new KConfigSkeleton::ItemInt( currentGroup(), QStringLiteral( "processingthreads" ), mProcessingthreads, 4 );
  itemProcessingthreads = new KConfigCompilerSignallingItem(innerItemProcessingthreads, this, notifyFunction, signalProcessingthreadsChanged);
  addItem( itemProcessingthreads, QStringLiteral( "processingthreads" ) );
  KConfigCompilerSignallingItem  *itemProxythreads;
  KConfigSkeleton::ItemInt  *innerItemProxythreads;
  innerItemProxythreads = new KConfigSkeleton::ItemInt( currentGroup(), QStringLiteral( "proxythreads" ), mProxythreads, 2 );
  itemProxythreads = new KConfigCompilerSignallingItem(innerItemProxythreads, this, notifyFunction, signalProxythreadsChanged);
  addItem( itemProxythreads, QStringLiteral( "proxythreads" ) );
  KConfigCompilerSignallingItem  *itemEncodethreads;
  KConfigSkeleton::ItemInt  *innerItemEncodethreads;
  innerItemEncodethreads = new KConfigSkeleton::ItemInt( currentGroup(), QStringLiteral( "encodethreads" ), mEncodethreads, 0 );
  itemEncodethreads = new KConfigCompilerSignallingItem(innerItemEncodethreads, this, notifyFunction, signalEncodethreadsChanged);
  addItem( itemEncodethreads, QStringLiteral( "encodethreads" ) );
  KConfigCompilerSignallingItem  *itemCurrenttmpfolder;
  KConfigSkeleton::ItemPath  *innerItemCurrenttmpfolder;
  innerItemCurrenttmpfolder = new KConfigSkeleton::ItemPath( currentGroup(), QStringLiteral( "currenttmpfolder" ), mCurrenttmpfolder, QStringLiteral( "/tmp/" ) );
  itemCurrenttmpfolder = new KConfigCompilerSignallingItem(innerItemCurrenttmpfolder, this, notifyFunction, signalCurrenttmpfolderChanged);
  addItem( itemCurrenttmpfolder, QStringLiteral( "currenttmpfolder" ) );
  KConfigCompilerSignallingItem  *itemMaxcachesize;
  KConfigSkeleton::ItemInt  *innerItemMaxcachesize;
  innerItemMaxcachesize = new KConfigSkeleton::ItemInt( currentGroup(), QStringLiteral( "maxcachesize" ), mMaxcachesize, 1024 );
  itemMaxcachesize = new KConfigCompilerSignallingItem(innerItemMaxcachesize, this, notifyFunction, signalMaxcachesizeChanged);
  addItem( itemMaxcachesize, QStringLiteral( "maxcachesize" ) );
  KConfigCompilerSignallingItem  *itemCheckForUpdate;
  KConfigSkeleton::ItemBool  *innerItemCheckForUpdate;
  innerItemCheckForUpdate = new KConfigSkeleton::ItemBool( currentGroup(), QStringLiteral( "checkForUpdate" ), mCheckForUpdate, true );
  itemCheckForUpdate = new KConfigCompilerSignallingItem(innerItemCheckForUpdate, this, notifyFunction, signalCheckForUpdateChanged);
  addItem( itemCheckForUpdate, QStringLiteral( "checkForUpdate" ) );
  KConfigCompilerSignallingItem  *itemUsePowerManagement;
  KConfigSkeleton::ItemBool  *innerItemUsePowerManagement;
  innerItemUsePowerManagement = new KConfigSkeleton::ItemBool( currentGroup(), QStringLiteral( "usePowerManagement" ), mUsePowerManagement, true );
  itemUsePowerManagement = new KConfigCompilerSignallingItem(innerItemUsePowerManagement, this, notifyFunction, signalUsePowerManagementChanged);
  addItem( itemUsePowerManagement, QStringLiteral( "usePowerManagement" ) );
  KConfigCompilerSignallingItem  *itemLastCacheCheck;
  KConfigSkeleton::ItemDateTime  *innerItemLastCacheCheck;
  innerItemLastCacheCheck = new KConfigSkeleton::ItemDateTime( currentGroup(), QStringLiteral( "lastCacheCheck" ), mLastCacheCheck );
  itemLastCacheCheck = new KConfigCompilerSignallingItem(innerItemLastCacheCheck, this, notifyFunction, signalLastCacheCheckChanged);
  addItem( itemLastCacheCheck, QStringLiteral( "lastCacheCheck" ) );
  KConfigCompilerSignallingItem  *itemDefaultprojectfolder;
  KConfigSkeleton::ItemPath  *innerItemDefaultprojectfolder;
  innerItemDefaultprojectfolder = new KConfigSkeleton::ItemPath( currentGroup(), QStringLiteral( "defaultprojectfolder" ), mDefaultprojectfolder );
  itemDefaultprojectfolder = new KConfigCompilerSignallingItem(innerItemDefaultprojectfolder, this, notifyFunction, signalDefaultprojectfolderChanged);
  addItem( itemDefaultprojectfolder, QStringLiteral( "defaultprojectfolder" ) );
  KConfigCompilerSignallingItem  *itemCustomprojectfolder;
  KConfigSkeleton::ItemBool  *innerItemCustomprojectfolder;
  innerItemCustomprojectfolder = new KConfigSkeleton::ItemBool( currentGroup(), QStringLiteral( "customprojectfolder" ), mCustomprojectfolder, false );
  itemCustomprojectfolder = new KConfigCompilerSignallingItem(innerItemCustomprojectfolder, this, notifyFunction, signalCustomprojectfolderChanged);
  addItem( itemCustomprojectfolder, QStringLiteral( "customprojectfolder" ) );
  KConfigCompilerSignallingItem  *itemSameprojectfolder;
  KConfigSkeleton::ItemBool  *innerItemSameprojectfolder;
  innerItemSameprojectfolder = new KConfigSkeleton::ItemBool( currentGroup(), QStringLiteral( "sameprojectfolder" ), mSameprojectfolder, false );
  itemSameprojectfolder = new KConfigCompilerSignallingItem(innerItemSameprojectfolder, this, notifyFunction, signalSameprojectfolderChanged);
  addItem( itemSameprojectfolder, QStringLiteral( "sameprojectfolder" ) );
  KConfigCompilerSignallingItem  *itemCapturetoprojectfolder;
  KConfigSkeleton::ItemInt  *innerItemCapturetoprojectfolder;
  innerItemCapturetoprojectfolder = new KConfigSkeleton::ItemInt( currentGroup(), QStringLiteral( "capturetoprojectfolder" ), mCapturetoprojectfolder, 1 );
  itemCapturetoprojectfolder = new KConfigCompilerSignallingItem(innerItemCapturetoprojectfolder, this, notifyFunction, signalCapturetoprojectfolderChanged);
  addItem( itemCapturetoprojectfolder, QStringLiteral( "capturetoprojectfolder" ) );
  KConfigCompilerSignallingItem  *itemCapturefolder;
  KConfigSkeleton::ItemPath  *innerItemCapturefolder;
  innerItemCapturefolder = new KConfigSkeleton::ItemPath( currentGroup(), QStringLiteral( "capturefolder" ), mCapturefolder, QStringLiteral( "$HOME" ) );
  itemCapturefolder = new KConfigCompilerSignallingItem(innerItemCapturefolder, this, notifyFunction, signalCapturefolderChanged);
  addItem( itemCapturefolder, QStringLiteral( "capturefolder" ) );
  KConfigCompilerSignallingItem  *itemCaptureprojectsubfolder;
  KConfigSkeleton::ItemString  *innerItemCaptureprojectsubfolder;
  innerItemCaptureprojectsubfolder = new KConfigSkeleton::ItemString( currentGroup(), QStringLiteral( "captureprojectsubfolder" ), mCaptureprojectsubfolder );
  itemCaptureprojectsubfolder = new KConfigCompilerSignallingItem(innerItemCaptureprojectsubfolder, this, notifyFunction, signalCaptureprojectsubfolderChanged);
  addItem( itemCaptureprojectsubfolder, QStringLiteral( "captureprojectsubfolder" ) );
  KConfigCompilerSignallingItem  *itemLibrarytodefaultfolder;
  KConfigSkeleton::ItemBool  *innerItemLibrarytodefaultfolder;
  innerItemLibrarytodefaultfolder = new KConfigSkeleton::ItemBool( currentGroup(), QStringLiteral( "librarytodefaultfolder" ), mLibrarytodefaultfolder, true );
  itemLibrarytodefaultfolder = new KConfigCompilerSignallingItem(innerItemLibrarytodefaultfolder, this, notifyFunction, signalLibrarytodefaultfolderChanged);
  addItem( itemLibrarytodefaultfolder, QStringLiteral( "librarytodefaultfolder" ) );
  KConfigCompilerSignallingItem  *itemVideotodefaultfolder;
  KConfigSkeleton::ItemInt  *innerItemVideotodefaultfolder;
  innerItemVideotodefaultfolder = new KConfigSkeleton::ItemInt( currentGroup(), QStringLiteral( "videotodefaultfolder" ), mVideotodefaultfolder, 0 );
  itemVideotodefaultfolder = new KConfigCompilerSignallingItem(innerItemVideotodefaultfolder, this, notifyFunction, signalVideotodefaultfolderChanged);
  addItem( itemVideotodefaultfolder, QStringLiteral( "videotodefaultfolder" ) );
  KConfigCompilerSignallingItem  *itemLibraryfolder;
  KConfigSkeleton::ItemPath  *innerItemLibraryfolder;
  innerItemLibraryfolder = new KConfigSkeleton::ItemPath( currentGroup(), QStringLiteral( "libraryfolder" ), mLibraryfolder );
  itemLibraryfolder = new KConfigCompilerSignallingItem(innerItemLibraryfolder, this, notifyFunction, signalLibraryfolderChanged);
  addItem( itemLibraryfolder, QStringLiteral( "libraryfolder" ) );
  KConfigCompilerSignallingItem  *itemVideofolder;
  KConfigSkeleton::ItemPath  *innerItemVideofolder;
  innerItemVideofolder = new KConfigSkeleton::ItemPath( currentGroup(), QStringLiteral( "videofolder" ), mVideofolder );
  itemVideofolder = new KConfigCompilerSignallingItem(innerItemVideofolder, this, notifyFunction, signalVideofolderChanged);
  addItem( itemVideofolder, QStringLiteral( "videofolder" ) );
  KConfigCompilerSignallingItem  *itemDefaultimageapp;
  KConfigSkeleton::ItemString  *innerItemDefaultimageapp;
  innerItemDefaultimageapp = new KConfigSkeleton::ItemString( currentGroup(), QStringLiteral( "defaultimageapp" ), mDefaultimageapp );
  itemDefaultimageapp = new KConfigCompilerSignallingItem(innerItemDefaultimageapp, this, notifyFunction, signalDefaultimageappChanged);
  addItem( itemDefaultimageapp, QStringLiteral( "defaultimageapp" ) );
  KConfigCompilerSignallingItem  *itemDefaultaudioapp;
  KConfigSkeleton::ItemString  *innerItemDefaultaudioapp;
  innerItemDefaultaudioapp = new KConfigSkeleton::ItemString( currentGroup(), QStringLiteral( "defaultaudioapp" ), mDefaultaudioapp );
  itemDefaultaudioapp = new KConfigCompilerSignallingItem(innerItemDefaultaudioapp, this, notifyFunction, signalDefaultaudioappChanged);
  addItem( itemDefaultaudioapp, QStringLiteral( "defaultaudioapp" ) );
  KConfigCompilerSignallingItem  *itemGlaxnimatePath;
  KConfigSkeleton::ItemString  *innerItemGlaxnimatePath;
  innerItemGlaxnimatePath = new KConfigSkeleton::ItemString( currentGroup(), QStringLiteral( "glaxnimatePath" ), mGlaxnimatePath );
  itemGlaxnimatePath = new KConfigCompilerSignallingItem(innerItemGlaxnimatePath, this, notifyFunction, signalGlaxnimatePathChanged);
  addItem( itemGlaxnimatePath, QStringLiteral( "glaxnimatePath" ) );
  KConfigCompilerSignallingItem  *itemDefaultvideoapp;
  KConfigSkeleton::ItemString  *innerItemDefaultvideoapp;
  innerItemDefaultvideoapp = new KConfigSkeleton::ItemString( currentGroup(), QStringLiteral( "defaultvideoapp" ), mDefaultvideoapp );
  itemDefaultvideoapp = new KConfigCompilerSignallingItem(innerItemDefaultvideoapp, this, notifyFunction, signalDefaultvideoappChanged);
  addItem( itemDefaultvideoapp, QStringLiteral( "defaultvideoapp" ) );
  KConfigCompilerSignallingItem  *itemNice_tasks;
  KConfigSkeleton::ItemBool  *innerItemNice_tasks;
  innerItemNice_tasks = new KConfigSkeleton::ItemBool( currentGroup(), QStringLiteral( "nice_tasks" ), mNice_tasks, true );
  itemNice_tasks = new KConfigCompilerSignallingItem(innerItemNice_tasks, this, notifyFunction, signalNice_tasksChanged);
  addItem( itemNice_tasks, QStringLiteral( "nice_tasks" ) );
  KConfigCompilerSignallingItem  *itemExportGuidesFormat;
  KConfigSkeleton::ItemString  *innerItemExportGuidesFormat;
  innerItemExportGuidesFormat = new KConfigSkeleton::ItemString( currentGroup(), QStringLiteral( "exportGuidesFormat" ), mExportGuidesFormat );
  itemExportGuidesFormat = new KConfigCompilerSignallingItem(innerItemExportGuidesFormat, this, notifyFunction, signalExportGuidesFormatChanged);
  addItem( itemExportGuidesFormat, QStringLiteral( "exportGuidesFormat" ) );
  KConfigCompilerSignallingItem  *itemMultipleguidesinterval;
  KConfigSkeleton::ItemDouble  *innerItemMultipleguidesinterval;
  innerItemMultipleguidesinterval = new KConfigSkeleton::ItemDouble( currentGroup(), QStringLiteral( "multipleguidesinterval" ), mMultipleguidesinterval, 30 );
  itemMultipleguidesinterval = new KConfigCompilerSignallingItem(innerItemMultipleguidesinterval, this, notifyFunction, signalMultipleguidesintervalChanged);
  addItem( itemMultipleguidesinterval, QStringLiteral( "multipleguidesinterval" ) );
  KConfigCompilerSignallingItem  *itemGuidesShowThumbs;
  KConfigSkeleton::ItemBool  *innerItemGuidesShowThumbs;
  innerItemGuidesShowThumbs = new KConfigSkeleton::ItemBool( currentGroup(), QStringLiteral( "guidesShowThumbs" ), mGuidesShowThumbs, false );
  itemGuidesShowThumbs = new KConfigCompilerSignallingItem(innerItemGuidesShowThumbs, this, notifyFunction, signalGuidesShowThumbsChanged);
  addItem( itemGuidesShowThumbs, QStringLiteral( "guidesShowThumbs" ) );
  KConfigCompilerSignallingItem  *itemGuidesSelectZone;
  KConfigSkeleton::ItemBool  *innerItemGuidesSelectZone;
  innerItemGuidesSelectZone = new KConfigSkeleton::ItemBool( currentGroup(), QStringLiteral( "guidesSelectZone" ), mGuidesSelectZone, false );
  itemGuidesSelectZone = new KConfigCompilerSignallingItem(innerItemGuidesSelectZone, this, notifyFunction, signalGuidesSelectZoneChanged);
  addItem( itemGuidesSelectZone, QStringLiteral( "guidesSelectZone" ) );

  setCurrentGroup( QStringLiteral( "capture" ) );

  KConfigCompilerSignallingItem  *itemDefaultaudiocapture;
  KConfigSkeleton::ItemString  *innerItemDefaultaudiocapture;
  innerItemDefaultaudiocapture = new KConfigSkeleton::ItemString( currentGroup(), QStringLiteral( "defaultaudiocapture" ), mDefaultaudiocapture, QStringLiteral( "default:" ) );
  itemDefaultaudiocapture = new KConfigCompilerSignallingItem(innerItemDefaultaudiocapture, this, notifyFunction, signalDefaultaudiocaptureChanged);
  addItem( itemDefaultaudiocapture, QStringLiteral( "defaultaudiocapture" ) );
  KConfigCompilerSignallingItem  *itemAudiocapturevolume;
  KConfigSkeleton::ItemInt  *innerItemAudiocapturevolume;
  innerItemAudiocapturevolume = new KConfigSkeleton::ItemInt( currentGroup(), QStringLiteral( "audiocapturevolume" ), mAudiocapturevolume, 100 );
  itemAudiocapturevolume = new KConfigCompilerSignallingItem(innerItemAudiocapturevolume, this, notifyFunction, signalAudiocapturevolumeChanged);
  addItem( itemAudiocapturevolume, QStringLiteral( "audiocapturevolume" ) );
  KConfigCompilerSignallingItem  *itemAudiocapturechannels;
  KConfigSkeleton::ItemInt  *innerItemAudiocapturechannels;
  innerItemAudiocapturechannels = new KConfigSkeleton::ItemInt( currentGroup(), QStringLiteral( "audiocapturechannels" ), mAudiocapturechannels, 2 );
  itemAudiocapturechannels = new KConfigCompilerSignallingItem(innerItemAudiocapturechannels, this, notifyFunction, signalAudiocapturechannelsChanged);
  addItem( itemAudiocapturechannels, QStringLiteral( "audiocapturechannels" ) );
  KConfigCompilerSignallingItem  *itemAudiocapturesamplerate;
  KConfigSkeleton::ItemInt  *innerItemAudiocapturesamplerate;
  innerItemAudiocapturesamplerate = new KConfigSkeleton::ItemInt( currentGroup(), QStringLiteral( "audiocapturesamplerate" ), mAudiocapturesamplerate, 48000 );
  itemAudiocapturesamplerate = new KConfigCompilerSignallingItem(innerItemAudiocapturesamplerate, this, notifyFunction, signalAudiocapturesamplerateChanged);
  addItem( itemAudiocapturesamplerate, QStringLiteral( "audiocapturesamplerate" ) );
  KConfigCompilerSignallingItem  *itemAudiocapturesampleformat;
  KConfigSkeleton::ItemInt  *innerItemAudiocapturesampleformat;
  innerItemAudiocapturesampleformat = new KConfigSkeleton::ItemInt( currentGroup(), QStringLiteral( "audiocapturesampleformat" ), mAudiocapturesampleformat, 2 );
  itemAudiocapturesampleformat = new KConfigCompilerSignallingItem(innerItemAudiocapturesampleformat, this, notifyFunction, signalAudiocapturesampleformatChanged);
  addItem( itemAudiocapturesampleformat, QStringLiteral( "audiocapturesampleformat" ) );
  KConfigCompilerSignallingItem  *itemDefaultcapture;
  KConfigSkeleton::ItemInt  *innerItemDefaultcapture;
  innerItemDefaultcapture = new KConfigSkeleton::ItemInt( currentGroup(), QStringLiteral( "defaultcapture" ), mDefaultcapture, 0 );
  itemDefaultcapture = new KConfigCompilerSignallingItem(innerItemDefaultcapture, this, notifyFunction, signalDefaultcaptureChanged);
  addItem( itemDefaultcapture, QStringLiteral( "defaultcapture" ) );
  KConfigCompilerSignallingItem  *itemAlsachannels;
  KConfigSkeleton::ItemUInt  *innerItemAlsachannels;
  innerItemAlsachannels = new KConfigSkeleton::ItemUInt( currentGroup(), QStringLiteral( "alsachannels" ), mAlsachannels, 2 );
  itemAlsachannels = new KConfigCompilerSignallingItem(innerItemAlsachannels, this, notifyFunction, signalAlsachannelsChanged);
  addItem( itemAlsachannels, QStringLiteral( "alsachannels" ) );
  KConfigCompilerSignallingItem  *itemGrab_profile;
  KConfigSkeleton::ItemInt  *innerItemGrab_profile;
  innerItemGrab_profile = new KConfigSkeleton::ItemInt( currentGroup(), QStringLiteral( "grab_profile" ), mGrab_profile, 0 );
  itemGrab_profile = new KConfigCompilerSignallingItem(innerItemGrab_profile, this, notifyFunction, signalGrab_profileChanged);
  addItem( itemGrab_profile, QStringLiteral( "grab_profile" ) );
  KConfigCompilerSignallingItem  *itemGrab_parameters;
  KConfigSkeleton::ItemString  *innerItemGrab_parameters;
  innerItemGrab_parameters = new KConfigSkeleton::ItemString( currentGroup(), QStringLiteral( "grab_parameters" ), mGrab_parameters );
  itemGrab_parameters = new KConfigCompilerSignallingItem(innerItemGrab_parameters, this, notifyFunction, signalGrab_parametersChanged);
  addItem( itemGrab_parameters, QStringLiteral( "grab_parameters" ) );
  KConfigCompilerSignallingItem  *itemGrab_extension;
  KConfigSkeleton::ItemString  *innerItemGrab_extension;
  innerItemGrab_extension = new KConfigSkeleton::ItemString( currentGroup(), QStringLiteral( "grab_extension" ), mGrab_extension );
  itemGrab_extension = new KConfigCompilerSignallingItem(innerItemGrab_extension, this, notifyFunction, signalGrab_extensionChanged);
  addItem( itemGrab_extension, QStringLiteral( "grab_extension" ) );
  KConfigCompilerSignallingItem  *itemGrab_capture_type;
  KConfigSkeleton::ItemInt  *innerItemGrab_capture_type;
  innerItemGrab_capture_type = new KConfigSkeleton::ItemInt( currentGroup(), QStringLiteral( "grab_capture_type" ), mGrab_capture_type, 0 );
  itemGrab_capture_type = new KConfigCompilerSignallingItem(innerItemGrab_capture_type, this, notifyFunction, signalGrab_capture_typeChanged);
  addItem( itemGrab_capture_type, QStringLiteral( "grab_capture_type" ) );
  KConfigCompilerSignallingItem  *itemGrab_follow_mouse;
  KConfigSkeleton::ItemBool  *innerItemGrab_follow_mouse;
  innerItemGrab_follow_mouse = new KConfigSkeleton::ItemBool( currentGroup(), QStringLiteral( "grab_follow_mouse" ), mGrab_follow_mouse, false );
  itemGrab_follow_mouse = new KConfigCompilerSignallingItem(innerItemGrab_follow_mouse, this, notifyFunction, signalGrab_follow_mouseChanged);
  addItem( itemGrab_follow_mouse, QStringLiteral( "grab_follow_mouse" ) );
  KConfigCompilerSignallingItem  *itemGrab_offsetx;
  KConfigSkeleton::ItemInt  *innerItemGrab_offsetx;
  innerItemGrab_offsetx = new KConfigSkeleton::ItemInt( currentGroup(), QStringLiteral( "grab_offsetx" ), mGrab_offsetx, 0 );
  itemGrab_offsetx = new KConfigCompilerSignallingItem(innerItemGrab_offsetx, this, notifyFunction, signalGrab_offsetxChanged);
  addItem( itemGrab_offsetx, QStringLiteral( "grab_offsetx" ) );
  KConfigCompilerSignallingItem  *itemGrab_offsety;
  KConfigSkeleton::ItemInt  *innerItemGrab_offsety;
  innerItemGrab_offsety = new KConfigSkeleton::ItemInt( currentGroup(), QStringLiteral( "grab_offsety" ), mGrab_offsety, 0 );
  itemGrab_offsety = new KConfigCompilerSignallingItem(innerItemGrab_offsety, this, notifyFunction, signalGrab_offsetyChanged);
  addItem( itemGrab_offsety, QStringLiteral( "grab_offsety" ) );
  KConfigCompilerSignallingItem  *itemGrab_width;
  KConfigSkeleton::ItemInt  *innerItemGrab_width;
  innerItemGrab_width = new KConfigSkeleton::ItemInt( currentGroup(), QStringLiteral( "grab_width" ), mGrab_width, 1280 );
  itemGrab_width = new KConfigCompilerSignallingItem(innerItemGrab_width, this, notifyFunction, signalGrab_widthChanged);
  addItem( itemGrab_width, QStringLiteral( "grab_width" ) );
  KConfigCompilerSignallingItem  *itemGrab_height;
  KConfigSkeleton::ItemInt  *innerItemGrab_height;
  innerItemGrab_height = new KConfigSkeleton::ItemInt( currentGroup(), QStringLiteral( "grab_height" ), mGrab_height, 720 );
  itemGrab_height = new KConfigCompilerSignallingItem(innerItemGrab_height, this, notifyFunction, signalGrab_heightChanged);
  addItem( itemGrab_height, QStringLiteral( "grab_height" ) );
  KConfigCompilerSignallingItem  *itemGrab_fps;
  KConfigSkeleton::ItemDouble  *innerItemGrab_fps;
  innerItemGrab_fps = new KConfigSkeleton::ItemDouble( currentGroup(), QStringLiteral( "grab_fps" ), mGrab_fps, 15.0 );
  itemGrab_fps = new KConfigCompilerSignallingItem(innerItemGrab_fps, this, notifyFunction, signalGrab_fpsChanged);
  addItem( itemGrab_fps, QStringLiteral( "grab_fps" ) );
  KConfigCompilerSignallingItem  *itemGrab_hide_frame;
  KConfigSkeleton::ItemBool  *innerItemGrab_hide_frame;
  innerItemGrab_hide_frame = new KConfigSkeleton::ItemBool( currentGroup(), QStringLiteral( "grab_hide_frame" ), mGrab_hide_frame, true );
  itemGrab_hide_frame = new KConfigCompilerSignallingItem(innerItemGrab_hide_frame, this, notifyFunction, signalGrab_hide_frameChanged);
  addItem( itemGrab_hide_frame, QStringLiteral( "grab_hide_frame" ) );
  KConfigCompilerSignallingItem  *itemGrab_hide_mouse;
  KConfigSkeleton::ItemBool  *innerItemGrab_hide_mouse;
  innerItemGrab_hide_mouse = new KConfigSkeleton::ItemBool( currentGroup(), QStringLiteral( "grab_hide_mouse" ), mGrab_hide_mouse, false );
  itemGrab_hide_mouse = new KConfigCompilerSignallingItem(innerItemGrab_hide_mouse, this, notifyFunction, signalGrab_hide_mouseChanged);
  addItem( itemGrab_hide_mouse, QStringLiteral( "grab_hide_mouse" ) );
  KConfigCompilerSignallingItem  *itemDecklink_device_found;
  KConfigSkeleton::ItemBool  *innerItemDecklink_device_found;
  innerItemDecklink_device_found = new KConfigSkeleton::ItemBool( currentGroup(), QStringLiteral( "decklink_device_found" ), mDecklink_device_found, false );
  itemDecklink_device_found = new KConfigCompilerSignallingItem(innerItemDecklink_device_found, this, notifyFunction, signalDecklink_device_foundChanged);
  addItem( itemDecklink_device_found, QStringLiteral( "decklink_device_found" ) );
  KConfigCompilerSignallingItem  *itemDecklink_capturedevice;
  KConfigSkeleton::ItemUInt  *innerItemDecklink_capturedevice;
  innerItemDecklink_capturedevice = new KConfigSkeleton::ItemUInt( currentGroup(), QStringLiteral( "decklink_capturedevice" ), mDecklink_capturedevice, 0 );
  itemDecklink_capturedevice = new KConfigCompilerSignallingItem(innerItemDecklink_capturedevice, this, notifyFunction, signalDecklink_capturedeviceChanged);
  addItem( itemDecklink_capturedevice, QStringLiteral( "decklink_capturedevice" ) );
  KConfigCompilerSignallingItem  *itemDecklink_profile;
  KConfigSkeleton::ItemInt  *innerItemDecklink_profile;
  innerItemDecklink_profile = new KConfigSkeleton::ItemInt( currentGroup(), QStringLiteral( "decklink_profile" ), mDecklink_profile, 0 );
  itemDecklink_profile = new KConfigCompilerSignallingItem(innerItemDecklink_profile, this, notifyFunction, signalDecklink_profileChanged);
  addItem( itemDecklink_profile, QStringLiteral( "decklink_profile" ) );
  KConfigCompilerSignallingItem  *itemDecklink_filename;
  KConfigSkeleton::ItemString  *innerItemDecklink_filename;
  innerItemDecklink_filename = new KConfigSkeleton::ItemString( currentGroup(), QStringLiteral( "decklink_filename" ), mDecklink_filename, QStringLiteral( "capture" ) );
  itemDecklink_filename = new KConfigCompilerSignallingItem(innerItemDecklink_filename, this, notifyFunction, signalDecklink_filenameChanged);
  addItem( itemDecklink_filename, QStringLiteral( "decklink_filename" ) );
  KConfigCompilerSignallingItem  *itemDecklink_parameters;
  KConfigSkeleton::ItemString  *innerItemDecklink_parameters;
  innerItemDecklink_parameters = new KConfigSkeleton::ItemString( currentGroup(), QStringLiteral( "decklink_parameters" ), mDecklink_parameters );
  itemDecklink_parameters = new KConfigCompilerSignallingItem(innerItemDecklink_parameters, this, notifyFunction, signalDecklink_parametersChanged);
  addItem( itemDecklink_parameters, QStringLiteral( "decklink_parameters" ) );
  KConfigCompilerSignallingItem  *itemDecklink_extension;
  KConfigSkeleton::ItemString  *innerItemDecklink_extension;
  innerItemDecklink_extension = new KConfigSkeleton::ItemString( currentGroup(), QStringLiteral( "decklink_extension" ), mDecklink_extension );
  itemDecklink_extension = new KConfigCompilerSignallingItem(innerItemDecklink_extension, this, notifyFunction, signalDecklink_extensionChanged);
  addItem( itemDecklink_extension, QStringLiteral( "decklink_extension" ) );

  setCurrentGroup( QStringLiteral( "shuttle" ) );

  KConfigCompilerSignallingItem  *itemEnableshuttle;
  KConfigSkeleton::ItemBool  *innerItemEnableshuttle;
  innerItemEnableshuttle = new KConfigSkeleton::ItemBool( currentGroup(), QStringLiteral( "enableshuttle" ), mEnableshuttle, false );
  itemEnableshuttle = new KConfigCompilerSignallingItem(innerItemEnableshuttle, this, notifyFunction, signalEnableshuttleChanged);
  addItem( itemEnableshuttle, QStringLiteral( "enableshuttle" ) );
  KConfigCompilerSignallingItem  *itemShuttledevice;
  KConfigSkeleton::ItemString  *innerItemShuttledevice;
  innerItemShuttledevice = new KConfigSkeleton::ItemString( currentGroup(), QStringLiteral( "shuttledevice" ), mShuttledevice );
  itemShuttledevice = new KConfigCompilerSignallingItem(innerItemShuttledevice, this, notifyFunction, signalShuttledeviceChanged);
  addItem( itemShuttledevice, QStringLiteral( "shuttledevice" ) );
  KConfigCompilerSignallingItem  *itemShuttledevicenames;
  KConfigSkeleton::ItemStringList  *innerItemShuttledevicenames;
  innerItemShuttledevicenames = new KConfigSkeleton::ItemStringList( currentGroup(), QStringLiteral( "shuttledevicenames" ), mShuttledevicenames );
  itemShuttledevicenames = new KConfigCompilerSignallingItem(innerItemShuttledevicenames, this, notifyFunction, signalShuttledevicenamesChanged);
  addItem( itemShuttledevicenames, QStringLiteral( "shuttledevicenames" ) );
  KConfigCompilerSignallingItem  *itemShuttledevicepaths;
  KConfigSkeleton::ItemStringList  *innerItemShuttledevicepaths;
  innerItemShuttledevicepaths = new KConfigSkeleton::ItemStringList( currentGroup(), QStringLiteral( "shuttledevicepaths" ), mShuttledevicepaths );
  itemShuttledevicepaths = new KConfigCompilerSignallingItem(innerItemShuttledevicepaths, this, notifyFunction, signalShuttledevicepathsChanged);
  addItem( itemShuttledevicepaths, QStringLiteral( "shuttledevicepaths" ) );
  KConfigCompilerSignallingItem  *itemShuttlebuttons;
  KConfigSkeleton::ItemString  *innerItemShuttlebuttons;
  innerItemShuttlebuttons = new KConfigSkeleton::ItemString( currentGroup(), QStringLiteral( "shuttlebuttons" ), mShuttlebuttons );
  itemShuttlebuttons = new KConfigCompilerSignallingItem(innerItemShuttlebuttons, this, notifyFunction, signalShuttlebuttonsChanged);
  addItem( itemShuttlebuttons, QStringLiteral( "shuttlebuttons" ) );

  setCurrentGroup( QStringLiteral( "bezier_spline" ) );

  KConfigCompilerSignallingItem  *itemBezier_gridlines;
  KConfigSkeleton::ItemInt  *innerItemBezier_gridlines;
  innerItemBezier_gridlines = new KConfigSkeleton::ItemInt( currentGroup(), QStringLiteral( "bezier_gridlines" ), mBezier_gridlines, 3 );
  itemBezier_gridlines = new KConfigCompilerSignallingItem(innerItemBezier_gridlines, this, notifyFunction, signalBezier_gridlinesChanged);
  addItem( itemBezier_gridlines, QStringLiteral( "bezier_gridlines" ) );
  KConfigCompilerSignallingItem  *itemBezier_showpixmap;
  KConfigSkeleton::ItemBool  *innerItemBezier_showpixmap;
  innerItemBezier_showpixmap = new KConfigSkeleton::ItemBool( currentGroup(), QStringLiteral( "bezier_showpixmap" ), mBezier_showpixmap, false );
  itemBezier_showpixmap = new KConfigCompilerSignallingItem(innerItemBezier_showpixmap, this, notifyFunction, signalBezier_showpixmapChanged);
  addItem( itemBezier_showpixmap, QStringLiteral( "bezier_showpixmap" ) );
  KConfigCompilerSignallingItem  *itemBezier_showallhandles;
  KConfigSkeleton::ItemBool  *innerItemBezier_showallhandles;
  innerItemBezier_showallhandles = new KConfigSkeleton::ItemBool( currentGroup(), QStringLiteral( "bezier_showallhandles" ), mBezier_showallhandles, true );
  itemBezier_showallhandles = new KConfigCompilerSignallingItem(innerItemBezier_showallhandles, this, notifyFunction, signalBezier_showallhandlesChanged);
  addItem( itemBezier_showallhandles, QStringLiteral( "bezier_showallhandles" ) );

  setCurrentGroup( QStringLiteral( "drag_value" ) );

  KConfigCompilerSignallingItem  *itemDragvalue_mode;
  KConfigSkeleton::ItemInt  *innerItemDragvalue_mode;
  innerItemDragvalue_mode = new KConfigSkeleton::ItemInt( currentGroup(), QStringLiteral( "dragvalue_mode" ), mDragvalue_mode, 0 );
  itemDragvalue_mode = new KConfigCompilerSignallingItem(innerItemDragvalue_mode, this, notifyFunction, signalDragvalue_modeChanged);
  addItem( itemDragvalue_mode, QStringLiteral( "dragvalue_mode" ) );
  KConfigCompilerSignallingItem  *itemDragvalue_directupdate;
  KConfigSkeleton::ItemBool  *innerItemDragvalue_directupdate;
  innerItemDragvalue_directupdate = new KConfigSkeleton::ItemBool( currentGroup(), QStringLiteral( "dragvalue_directupdate" ), mDragvalue_directupdate, true );
  itemDragvalue_directupdate = new KConfigCompilerSignallingItem(innerItemDragvalue_directupdate, this, notifyFunction, signalDragvalue_directupdateChanged);
  addItem( itemDragvalue_directupdate, QStringLiteral( "dragvalue_directupdate" ) );

  setCurrentGroup( QStringLiteral( "Recent Profiles" ) );

  KConfigCompilerSignallingItem  *itemRecentProfiles;
  KConfigSkeleton::ItemStringList  *innerItemRecentProfiles;
  innerItemRecentProfiles = new KConfigSkeleton::ItemStringList( currentGroup(), QStringLiteral( "recentProfiles" ), mRecentProfiles );
  itemRecentProfiles = new KConfigCompilerSignallingItem(innerItemRecentProfiles, this, notifyFunction, signalRecentProfilesChanged);
  addItem( itemRecentProfiles, QStringLiteral( "recentProfiles" ) );
  KConfigCompilerSignallingItem  *itemRecentProfileNames;
  KConfigSkeleton::ItemStringList  *innerItemRecentProfileNames;
  innerItemRecentProfileNames = new KConfigSkeleton::ItemStringList( currentGroup(), QStringLiteral( "recentProfileNames" ), mRecentProfileNames );
  itemRecentProfileNames = new KConfigCompilerSignallingItem(innerItemRecentProfileNames, this, notifyFunction, signalRecentProfileNamesChanged);
  addItem( itemRecentProfileNames, QStringLiteral( "recentProfileNames" ) );

  setCurrentGroup( QStringLiteral( "unmanaged" ) );

  KConfigCompilerSignallingItem  *itemProperties_panel_page;
  KConfigSkeleton::ItemInt  *innerItemProperties_panel_page;
  innerItemProperties_panel_page = new KConfigSkeleton::ItemInt( currentGroup(), QStringLiteral( "properties_panel_page" ), mProperties_panel_page, 0 );
  itemProperties_panel_page = new KConfigCompilerSignallingItem(innerItemProperties_panel_page, this, notifyFunction, signalProperties_panel_pageChanged);
  addItem( itemProperties_panel_page, QStringLiteral( "properties_panel_page" ) );
  KConfigCompilerSignallingItem  *itemProject_fps;
  KConfigSkeleton::ItemDouble  *innerItemProject_fps;
  innerItemProject_fps = new KConfigSkeleton::ItemDouble( currentGroup(), QStringLiteral( "project_fps" ), mProject_fps, 25 );
  itemProject_fps = new KConfigCompilerSignallingItem(innerItemProject_fps, this, notifyFunction, signalProject_fpsChanged);
  addItem( itemProject_fps, QStringLiteral( "project_fps" ) );
  KConfigCompilerSignallingItem  *itemDefault_profile;
  KConfigSkeleton::ItemString  *innerItemDefault_profile;
  innerItemDefault_profile = new KConfigSkeleton::ItemString( currentGroup(), QStringLiteral( "default_profile" ), mDefault_profile );
  itemDefault_profile = new KConfigCompilerSignallingItem(innerItemDefault_profile, this, notifyFunction, signalDefault_profileChanged);
  addItem( itemDefault_profile, QStringLiteral( "default_profile" ) );
  KConfigCompilerSignallingItem  *itemKdockLayout;
  KConfigSkeleton::ItemString  *innerItemKdockLayout;
  innerItemKdockLayout = new KConfigSkeleton::ItemString( currentGroup(), QStringLiteral( "kdockLayout" ), mKdockLayout );
  itemKdockLayout = new KConfigCompilerSignallingItem(innerItemKdockLayout, this, notifyFunction, signalKdockLayoutChanged);
  addItem( itemKdockLayout, QStringLiteral( "kdockLayout" ) );
  QStringList defaultlayoutsOrder;
  defaultlayoutsOrder.append( QString::fromUtf8( "logging" ) );
  defaultlayoutsOrder.append( QString::fromUtf8( "editing" ) );
  defaultlayoutsOrder.append( QString::fromUtf8( "audio" ) );
  defaultlayoutsOrder.append( QString::fromUtf8( "effects" ) );
  defaultlayoutsOrder.append( QString::fromUtf8( "color" ) );

  KConfigCompilerSignallingItem  *itemLayoutsOrder;
  KConfigSkeleton::ItemStringList  *innerItemLayoutsOrder;
  innerItemLayoutsOrder = new KConfigSkeleton::ItemStringList( currentGroup(), QStringLiteral( "layoutsOrder" ), mLayoutsOrder, defaultlayoutsOrder );
  itemLayoutsOrder = new KConfigCompilerSignallingItem(innerItemLayoutsOrder, this, notifyFunction, signalLayoutsOrderChanged);
  addItem( itemLayoutsOrder, QStringLiteral( "layoutsOrder" ) );
  KConfigCompilerSignallingItem  *itemShowdescriptioncolumn;
  KConfigSkeleton::ItemBool  *innerItemShowdescriptioncolumn;
  innerItemShowdescriptioncolumn = new KConfigSkeleton::ItemBool( currentGroup(), QStringLiteral( "showdescriptioncolumn" ), mShowdescriptioncolumn, true );
  itemShowdescriptioncolumn = new KConfigCompilerSignallingItem(innerItemShowdescriptioncolumn, this, notifyFunction, signalShowdescriptioncolumnChanged);
  addItem( itemShowdescriptioncolumn, QStringLiteral( "showdescriptioncolumn" ) );
  KConfigCompilerSignallingItem  *itemShowratingcolumn;
  KConfigSkeleton::ItemBool  *innerItemShowratingcolumn;
  innerItemShowratingcolumn = new KConfigSkeleton::ItemBool( currentGroup(), QStringLiteral( "showratingcolumn" ), mShowratingcolumn, false );
  itemShowratingcolumn = new KConfigCompilerSignallingItem(innerItemShowratingcolumn, this, notifyFunction, signalShowratingcolumnChanged);
  addItem( itemShowratingcolumn, QStringLiteral( "showratingcolumn" ) );
  KConfigCompilerSignallingItem  *itemShowdatecolumn;
  KConfigSkeleton::ItemBool  *innerItemShowdatecolumn;
  innerItemShowdatecolumn = new KConfigSkeleton::ItemBool( currentGroup(), QStringLiteral( "showdatecolumn" ), mShowdatecolumn, false );
  itemShowdatecolumn = new KConfigCompilerSignallingItem(innerItemShowdatecolumn, this, notifyFunction, signalShowdatecolumnChanged);
  addItem( itemShowdatecolumn, QStringLiteral( "showdatecolumn" ) );
  KConfigCompilerSignallingItem  *itemFrametimecode;
  KConfigSkeleton::ItemBool  *innerItemFrametimecode;
  innerItemFrametimecode = new KConfigSkeleton::ItemBool( currentGroup(), QStringLiteral( "frametimecode" ), mFrametimecode, false );
  itemFrametimecode = new KConfigCompilerSignallingItem(innerItemFrametimecode, this, notifyFunction, signalFrametimecodeChanged);
  addItem( itemFrametimecode, QStringLiteral( "frametimecode" ) );
  KConfigCompilerSignallingItem  *itemRectimecode;
  KConfigSkeleton::ItemBool  *innerItemRectimecode;
  innerItemRectimecode = new KConfigSkeleton::ItemBool( currentGroup(), QStringLiteral( "rectimecode" ), mRectimecode, false );
  itemRectimecode = new KConfigCompilerSignallingItem(innerItemRectimecode, this, notifyFunction, signalRectimecodeChanged);
  addItem( itemRectimecode, QStringLiteral( "rectimecode" ) );
  KConfigCompilerSignallingItem  *itemSnaptopoints;
  KConfigSkeleton::ItemBool  *innerItemSnaptopoints;
  innerItemSnaptopoints = new KConfigSkeleton::ItemBool( currentGroup(), QStringLiteral( "snaptopoints" ), mSnaptopoints, true );
  itemSnaptopoints = new KConfigCompilerSignallingItem(innerItemSnaptopoints, this, notifyFunction, signalSnaptopointsChanged);
  addItem( itemSnaptopoints, QStringLiteral( "snaptopoints" ) );
  KConfigCompilerSignallingItem  *itemShowClipOverlays;
  KConfigSkeleton::ItemBool  *innerItemShowClipOverlays;
  innerItemShowClipOverlays = new KConfigSkeleton::ItemBool( currentGroup(), QStringLiteral( "showClipOverlays" ), mShowClipOverlays, true );
  itemShowClipOverlays = new KConfigCompilerSignallingItem(innerItemShowClipOverlays, this, notifyFunction, signalShowClipOverlaysChanged);
  addItem( itemShowClipOverlays, QStringLiteral( "showClipOverlays" ) );
  KConfigCompilerSignallingItem  *itemRippleResize;
  KConfigSkeleton::ItemBool  *innerItemRippleResize;
  innerItemRippleResize = new KConfigSkeleton::ItemBool( currentGroup(), QStringLiteral( "rippleResize" ), mRippleResize, false );
  itemRippleResize = new KConfigCompilerSignallingItem(innerItemRippleResize, this, notifyFunction, signalRippleResizeChanged);
  addItem( itemRippleResize, QStringLiteral( "rippleResize" ) );
  KConfigCompilerSignallingItem  *itemLockedGuides;
  KConfigSkeleton::ItemBool  *innerItemLockedGuides;
  innerItemLockedGuides = new KConfigSkeleton::ItemBool( currentGroup(), QStringLiteral( "lockedGuides" ), mLockedGuides, true );
  itemLockedGuides = new KConfigCompilerSignallingItem(innerItemLockedGuides, this, notifyFunction, signalLockedGuidesChanged);
  addItem( itemLockedGuides, QStringLiteral( "lockedGuides" ) );
  KConfigCompilerSignallingItem  *itemGuidesCategories;
  KConfigSkeleton::ItemStringList  *innerItemGuidesCategories;
  innerItemGuidesCategories = new KConfigSkeleton::ItemStringList( currentGroup(), QStringLiteral( "guidesCategories" ), mGuidesCategories );
  itemGuidesCategories = new KConfigCompilerSignallingItem(innerItemGuidesCategories, this, notifyFunction, signalGuidesCategoriesChanged);
  addItem( itemGuidesCategories, QStringLiteral( "guidesCategories" ) );
  KConfigCompilerSignallingItem  *itemTagsintimeline;
  KConfigSkeleton::ItemBool  *innerItemTagsintimeline;
  innerItemTagsintimeline = new KConfigSkeleton::ItemBool( currentGroup(), QStringLiteral( "tagsintimeline" ), mTagsintimeline, true );
  itemTagsintimeline = new KConfigCompilerSignallingItem(innerItemTagsintimeline, this, notifyFunction, signalTagsintimelineChanged);
  addItem( itemTagsintimeline, QStringLiteral( "tagsintimeline" ) );
  KConfigCompilerSignallingItem  *itemTimelinemousezoomonplayhead;
  KConfigSkeleton::ItemBool  *innerItemTimelinemousezoomonplayhead;
  innerItemTimelinemousezoomonplayhead = new KConfigSkeleton::ItemBool( currentGroup(), QStringLiteral( "timelinemousezoomonplayhead" ), mTimelinemousezoomonplayhead, false );
  itemTimelinemousezoomonplayhead = new KConfigCompilerSignallingItem(innerItemTimelinemousezoomonplayhead, this, notifyFunction, signalTimelinemousezoomonplayheadChanged);
  addItem( itemTimelinemousezoomonplayhead, QStringLiteral( "timelinemousezoomonplayhead" ) );
  KConfigCompilerSignallingItem  *itemTransitionfollowcursor;
  KConfigSkeleton::ItemBool  *innerItemTransitionfollowcursor;
  innerItemTransitionfollowcursor = new KConfigSkeleton::ItemBool( currentGroup(), QStringLiteral( "transitionfollowcursor" ), mTransitionfollowcursor, true );
  itemTransitionfollowcursor = new KConfigCompilerSignallingItem(innerItemTransitionfollowcursor, this, notifyFunction, signalTransitionfollowcursorChanged);
  addItem( itemTransitionfollowcursor, QStringLiteral( "transitionfollowcursor" ) );
  KConfigCompilerSignallingItem  *itemKeyframeseek;
  KConfigSkeleton::ItemBool  *innerItemKeyframeseek;
  innerItemKeyframeseek = new KConfigSkeleton::ItemBool( currentGroup(), QStringLiteral( "keyframeseek" ), mKeyframeseek, true );
  itemKeyframeseek = new KConfigCompilerSignallingItem(innerItemKeyframeseek, this, notifyFunction, signalKeyframeseekChanged);
  addItem( itemKeyframeseek, QStringLiteral( "keyframeseek" ) );
  KConfigCompilerSignallingItem  *itemShoweffectinfo;
  KConfigSkeleton::ItemBool  *innerItemShoweffectinfo;
  innerItemShoweffectinfo = new KConfigSkeleton::ItemBool( currentGroup(), QStringLiteral( "showeffectinfo" ), mShoweffectinfo, false );
  itemShoweffectinfo = new KConfigCompilerSignallingItem(innerItemShoweffectinfo, this, notifyFunction, signalShoweffectinfoChanged);
  addItem( itemShoweffectinfo, QStringLiteral( "showeffectinfo" ) );
  KConfigCompilerSignallingItem  *itemApplyEffectParamsToGroup;
  KConfigSkeleton::ItemBool  *innerItemApplyEffectParamsToGroup;
  innerItemApplyEffectParamsToGroup = new KConfigSkeleton::ItemBool( currentGroup(), QStringLiteral( "applyEffectParamsToGroup" ), mApplyEffectParamsToGroup, false );
  itemApplyEffectParamsToGroup = new KConfigCompilerSignallingItem(innerItemApplyEffectParamsToGroup, this, notifyFunction, signalApplyEffectParamsToGroupChanged);
  addItem( itemApplyEffectParamsToGroup, QStringLiteral( "applyEffectParamsToGroup" ) );
  KConfigCompilerSignallingItem  *itemApplyEffectParamsToGroupWithSameValue;
  KConfigSkeleton::ItemBool  *innerItemApplyEffectParamsToGroupWithSameValue;
  innerItemApplyEffectParamsToGroupWithSameValue = new KConfigSkeleton::ItemBool( currentGroup(), QStringLiteral( "applyEffectParamsToGroupWithSameValue" ), mApplyEffectParamsToGroupWithSameValue, true );
  itemApplyEffectParamsToGroupWithSameValue = new KConfigCompilerSignallingItem(innerItemApplyEffectParamsToGroupWithSameValue, this, notifyFunction, signalApplyEffectParamsToGroupWithSameValueChanged);
  addItem( itemApplyEffectParamsToGroupWithSameValue, QStringLiteral( "applyEffectParamsToGroupWithSameValue" ) );
  KConfigCompilerSignallingItem  *itemRenderProfile;
  KConfigSkeleton::ItemString  *innerItemRenderProfile;
  innerItemRenderProfile = new KConfigSkeleton::ItemString( currentGroup(), QStringLiteral( "renderProfile" ), mRenderProfile, QStringLiteral( "MP4-H264/AAC" ) );
  itemRenderProfile = new KConfigCompilerSignallingItem(innerItemRenderProfile, this, notifyFunction, signalRenderProfileChanged);
  addItem( itemRenderProfile, QStringLiteral( "renderProfile" ) );
  KConfigCompilerSignallingItem  *itemKeepRenderLogFiles;
  KConfigSkeleton::ItemBool  *innerItemKeepRenderLogFiles;
  innerItemKeepRenderLogFiles = new KConfigSkeleton::ItemBool( currentGroup(), QStringLiteral( "keepRenderLogFiles" ), mKeepRenderLogFiles, false );
  itemKeepRenderLogFiles = new KConfigCompilerSignallingItem(innerItemKeepRenderLogFiles, this, notifyFunction, signalKeepRenderLogFilesChanged);
  addItem( itemKeepRenderLogFiles, QStringLiteral( "keepRenderLogFiles" ) );
  KConfigCompilerSignallingItem  *itemValidated_luts;
  KConfigSkeleton::ItemStringList  *innerItemValidated_luts;
  innerItemValidated_luts = new KConfigSkeleton::ItemStringList( currentGroup(), QStringLiteral( "validated_luts" ), mValidated_luts );
  itemValidated_luts = new KConfigCompilerSignallingItem(innerItemValidated_luts, this, notifyFunction, signalValidated_lutsChanged);
  addItem( itemValidated_luts, QStringLiteral( "validated_luts" ) );
  KConfigCompilerSignallingItem  *itemDisplayClipMonitorInfo;
  KConfigSkeleton::ItemInt  *innerItemDisplayClipMonitorInfo;
  innerItemDisplayClipMonitorInfo = new KConfigSkeleton::ItemInt( currentGroup(), QStringLiteral( "displayClipMonitorInfo" ), mDisplayClipMonitorInfo, 0x55 );
  itemDisplayClipMonitorInfo = new KConfigCompilerSignallingItem(innerItemDisplayClipMonitorInfo, this, notifyFunction, signalDisplayClipMonitorInfoChanged);
  addItem( itemDisplayClipMonitorInfo, QStringLiteral( "displayClipMonitorInfo" ) );
  KConfigCompilerSignallingItem  *itemShowClipMonitorSafeZone;
  KConfigSkeleton::ItemBool  *innerItemShowClipMonitorSafeZone;
  innerItemShowClipMonitorSafeZone = new KConfigSkeleton::ItemBool( currentGroup(), QStringLiteral( "showClipMonitorSafeZone" ), mShowClipMonitorSafeZone, false );
  itemShowClipMonitorSafeZone = new KConfigCompilerSignallingItem(innerItemShowClipMonitorSafeZone, this, notifyFunction, signalShowClipMonitorSafeZoneChanged);
  addItem( itemShowClipMonitorSafeZone, QStringLiteral( "showClipMonitorSafeZone" ) );
  KConfigCompilerSignallingItem  *itemShowProjectMonitorSafeZone;
  KConfigSkeleton::ItemBool  *innerItemShowProjectMonitorSafeZone;
  innerItemShowProjectMonitorSafeZone = new KConfigSkeleton::ItemBool( currentGroup(), QStringLiteral( "showProjectMonitorSafeZone" ), mShowProjectMonitorSafeZone, false );
  itemShowProjectMonitorSafeZone = new KConfigCompilerSignallingItem(innerItemShowProjectMonitorSafeZone, this, notifyFunction, signalShowProjectMonitorSafeZoneChanged);
  addItem( itemShowProjectMonitorSafeZone, QStringLiteral( "showProjectMonitorSafeZone" ) );
  KConfigCompilerSignallingItem  *itemDisplayProjectMonitorInfo;
  KConfigSkeleton::ItemInt  *innerItemDisplayProjectMonitorInfo;
  innerItemDisplayProjectMonitorInfo = new KConfigSkeleton::ItemInt( currentGroup(), QStringLiteral( "displayProjectMonitorInfo" ), mDisplayProjectMonitorInfo, 0x05 );
  itemDisplayProjectMonitorInfo = new KConfigCompilerSignallingItem(innerItemDisplayProjectMonitorInfo, this, notifyFunction, signalDisplayProjectMonitorInfoChanged);
  addItem( itemDisplayProjectMonitorInfo, QStringLiteral( "displayProjectMonitorInfo" ) );
  KConfigCompilerSignallingItem  *itemPreviewScaling;
  KConfigSkeleton::ItemInt  *innerItemPreviewScaling;
  innerItemPreviewScaling = new KConfigSkeleton::ItemInt( currentGroup(), QStringLiteral( "previewScaling" ), mPreviewScaling, 1 );
  itemPreviewScaling = new KConfigCompilerSignallingItem(innerItemPreviewScaling, this, notifyFunction, signalPreviewScalingChanged);
  addItem( itemPreviewScaling, QStringLiteral( "previewScaling" ) );
  KConfigCompilerSignallingItem  *itemAutoKeyframe;
  KConfigSkeleton::ItemBool  *innerItemAutoKeyframe;
  innerItemAutoKeyframe = new KConfigSkeleton::ItemBool( currentGroup(), QStringLiteral( "autoKeyframe" ), mAutoKeyframe, true );
  itemAutoKeyframe = new KConfigCompilerSignallingItem(innerItemAutoKeyframe, this, notifyFunction, signalAutoKeyframeChanged);
  addItem( itemAutoKeyframe, QStringLiteral( "autoKeyframe" ) );
  KConfigCompilerSignallingItem  *itemLimitAutoKeyframes;
  KConfigSkeleton::ItemInt  *innerItemLimitAutoKeyframes;
  innerItemLimitAutoKeyframes = new KConfigSkeleton::ItemInt( currentGroup(), QStringLiteral( "limitAutoKeyframes" ), mLimitAutoKeyframes, 0 );
  itemLimitAutoKeyframes = new KConfigCompilerSignallingItem(innerItemLimitAutoKeyframes, this, notifyFunction, signalLimitAutoKeyframesChanged);
  addItem( itemLimitAutoKeyframes, QStringLiteral( "limitAutoKeyframes" ) );
  KConfigCompilerSignallingItem  *itemLimitAutoKeyframesInterval;
  KConfigSkeleton::ItemInt  *innerItemLimitAutoKeyframesInterval;
  innerItemLimitAutoKeyframesInterval = new KConfigSkeleton::ItemInt( currentGroup(), QStringLiteral( "limitAutoKeyframesInterval" ), mLimitAutoKeyframesInterval, 10 );
  itemLimitAutoKeyframesInterval = new KConfigCompilerSignallingItem(innerItemLimitAutoKeyframesInterval, this, notifyFunction, signalLimitAutoKeyframesIntervalChanged);
  addItem( itemLimitAutoKeyframesInterval, QStringLiteral( "limitAutoKeyframesInterval" ) );
  KConfigCompilerSignallingItem  *itemMaskOpacity;
  KConfigSkeleton::ItemInt  *innerItemMaskOpacity;
  innerItemMaskOpacity = new KConfigSkeleton::ItemInt( currentGroup(), QStringLiteral( "maskOpacity" ), mMaskOpacity, 100 );
  itemMaskOpacity = new KConfigCompilerSignallingItem(innerItemMaskOpacity, this, notifyFunction, signalMaskOpacityChanged);
  addItem( itemMaskOpacity, QStringLiteral( "maskOpacity" ) );
  KConfigCompilerSignallingItem  *itemMaskInverted;
  KConfigSkeleton::ItemBool  *innerItemMaskInverted;
  innerItemMaskInverted = new KConfigSkeleton::ItemBool( currentGroup(), QStringLiteral( "maskInverted" ), mMaskInverted, false );
  itemMaskInverted = new KConfigCompilerSignallingItem(innerItemMaskInverted, this, notifyFunction, signalMaskInvertedChanged);
  addItem( itemMaskInverted, QStringLiteral( "maskInverted" ) );
  KConfigCompilerSignallingItem  *itemClipMonitorOverlayGuides;
  KConfigSkeleton::ItemInt  *innerItemClipMonitorOverlayGuides;
  innerItemClipMonitorOverlayGuides = new KConfigSkeleton::ItemInt( currentGroup(), QStringLiteral( "clipMonitorOverlayGuides" ), mClipMonitorOverlayGuides, 0 );
  itemClipMonitorOverlayGuides = new KConfigCompilerSignallingItem(innerItemClipMonitorOverlayGuides, this, notifyFunction, signalClipMonitorOverlayGuidesChanged);
  addItem( itemClipMonitorOverlayGuides, QStringLiteral( "clipMonitorOverlayGuides" ) );
  KConfigCompilerSignallingItem  *itemProjectMonitorOverlayGuides;
  KConfigSkeleton::ItemInt  *innerItemProjectMonitorOverlayGuides;
  innerItemProjectMonitorOverlayGuides = new KConfigSkeleton::ItemInt( currentGroup(), QStringLiteral( "projectMonitorOverlayGuides" ), mProjectMonitorOverlayGuides, 0 );
  itemProjectMonitorOverlayGuides = new KConfigCompilerSignallingItem(innerItemProjectMonitorOverlayGuides, this, notifyFunction, signalProjectMonitorOverlayGuidesChanged);
  addItem( itemProjectMonitorOverlayGuides, QStringLiteral( "projectMonitorOverlayGuides" ) );
  KConfigCompilerSignallingItem  *itemAlwaysShowMonitorAudio;
  KConfigSkeleton::ItemBool  *innerItemAlwaysShowMonitorAudio;
  innerItemAlwaysShowMonitorAudio = new KConfigSkeleton::ItemBool( currentGroup(), QStringLiteral( "alwaysShowMonitorAudio" ), mAlwaysShowMonitorAudio, false );
  itemAlwaysShowMonitorAudio = new KConfigCompilerSignallingItem(innerItemAlwaysShowMonitorAudio, this, notifyFunction, signalAlwaysShowMonitorAudioChanged);
  addItem( itemAlwaysShowMonitorAudio, QStringLiteral( "alwaysShowMonitorAudio" ) );
  KConfigCompilerSignallingItem  *itemDisplayAudioOverlay;
  KConfigSkeleton::ItemBool  *innerItemDisplayAudioOverlay;
  innerItemDisplayAudioOverlay = new KConfigSkeleton::ItemBool( currentGroup(), QStringLiteral( "displayAudioOverlay" ), mDisplayAudioOverlay, false );
  itemDisplayAudioOverlay = new KConfigCompilerSignallingItem(innerItemDisplayAudioOverlay, this, notifyFunction, signalDisplayAudioOverlayChanged);
  addItem( itemDisplayAudioOverlay, QStringLiteral( "displayAudioOverlay" ) );
  KConfigCompilerSignallingItem  *itemMonitoraudio;
  KConfigSkeleton::ItemInt  *innerItemMonitoraudio;
  innerItemMonitoraudio = new KConfigSkeleton::ItemInt( currentGroup(), QStringLiteral( "monitoraudio" ), mMonitoraudio, 0x07 );
  itemMonitoraudio = new KConfigCompilerSignallingItem(innerItemMonitoraudio, this, notifyFunction, signalMonitoraudioChanged);
  addItem( itemMonitoraudio, QStringLiteral( "monitoraudio" ) );
  KConfigCompilerSignallingItem  *itemShowOnMonitorScene;
  KConfigSkeleton::ItemBool  *innerItemShowOnMonitorScene;
  innerItemShowOnMonitorScene = new KConfigSkeleton::ItemBool( currentGroup(), QStringLiteral( "showOnMonitorScene" ), mShowOnMonitorScene, true );
  itemShowOnMonitorScene = new KConfigCompilerSignallingItem(innerItemShowOnMonitorScene, this, notifyFunction, signalShowOnMonitorSceneChanged);
  addItem( itemShowOnMonitorScene, QStringLiteral( "showOnMonitorScene" ) );
  KConfigCompilerSignallingItem  *itemAutoaudiodrivername;
  KConfigSkeleton::ItemString  *innerItemAutoaudiodrivername;
  innerItemAutoaudiodrivername = new KConfigSkeleton::ItemString( currentGroup(), QStringLiteral( "autoaudiodrivername" ), mAutoaudiodrivername );
  itemAutoaudiodrivername = new KConfigCompilerSignallingItem(innerItemAutoaudiodrivername, this, notifyFunction, signalAutoaudiodrivernameChanged);
  addItem( itemAutoaudiodrivername, QStringLiteral( "autoaudiodrivername" ) );
  KConfigCompilerSignallingItem  *itemMixerCollapse;
  KConfigSkeleton::ItemBool  *innerItemMixerCollapse;
  innerItemMixerCollapse = new KConfigSkeleton::ItemBool( currentGroup(), QStringLiteral( "mixerCollapse" ), mMixerCollapse, false );
  itemMixerCollapse = new KConfigCompilerSignallingItem(innerItemMixerCollapse, this, notifyFunction, signalMixerCollapseChanged);
  addItem( itemMixerCollapse, QStringLiteral( "mixerCollapse" ) );
  KConfigCompilerSignallingItem  *itemConsumerslist;
  KConfigSkeleton::ItemStringList  *innerItemConsumerslist;
  innerItemConsumerslist = new KConfigSkeleton::ItemStringList( currentGroup(), QStringLiteral( "consumerslist" ), mConsumerslist );
  itemConsumerslist = new KConfigCompilerSignallingItem(innerItemConsumerslist, this, notifyFunction, signalConsumerslistChanged);
  addItem( itemConsumerslist, QStringLiteral( "consumerslist" ) );
  KConfigCompilerSignallingItem  *itemProducerslist;
  KConfigSkeleton::ItemStringList  *innerItemProducerslist;
  innerItemProducerslist = new KConfigSkeleton::ItemStringList( currentGroup(), QStringLiteral( "producerslist" ), mProducerslist );
  itemProducerslist = new KConfigCompilerSignallingItem(innerItemProducerslist, this, notifyFunction, signalProducerslistChanged);
  addItem( itemProducerslist, QStringLiteral( "producerslist" ) );
  KConfigCompilerSignallingItem  *itemWidgetstyle;
  KConfigSkeleton::ItemString  *innerItemWidgetstyle;
  innerItemWidgetstyle = new KConfigSkeleton::ItemString( currentGroup(), QStringLiteral( "widgetstyle" ), mWidgetstyle );
  itemWidgetstyle = new KConfigCompilerSignallingItem(innerItemWidgetstyle, this, notifyFunction, signalWidgetstyleChanged);
  addItem( itemWidgetstyle, QStringLiteral( "widgetstyle" ) );
  KConfigCompilerSignallingItem  *itemShowslideshowthumbs;
  KConfigSkeleton::ItemBool  *innerItemShowslideshowthumbs;
  innerItemShowslideshowthumbs = new KConfigSkeleton::ItemBool( currentGroup(), QStringLiteral( "showslideshowthumbs" ), mShowslideshowthumbs, false );
  itemShowslideshowthumbs = new KConfigCompilerSignallingItem(innerItemShowslideshowthumbs, this, notifyFunction, signalShowslideshowthumbsChanged);
  addItem( itemShowslideshowthumbs, QStringLiteral( "showslideshowthumbs" ) );
  KConfigCompilerSignallingItem  *itemShowtitlebars;
  KConfigSkeleton::ItemBool  *innerItemShowtitlebars;
  innerItemShowtitlebars = new KConfigSkeleton::ItemBool( currentGroup(), QStringLiteral( "showtitlebars" ), mShowtitlebars, true );
  itemShowtitlebars = new KConfigCompilerSignallingItem(innerItemShowtitlebars, this, notifyFunction, signalShowtitlebarsChanged);
  addItem( itemShowtitlebars, QStringLiteral( "showtitlebars" ) );
  KConfigCompilerSignallingItem  *itemColorclipcolor;
  KConfigSkeleton::ItemColor  *innerItemColorclipcolor;
  innerItemColorclipcolor = new KConfigSkeleton::ItemColor( currentGroup(), QStringLiteral( "colorclipcolor" ), mColorclipcolor, QColor( "#000000" ) );
  itemColorclipcolor = new KConfigCompilerSignallingItem(innerItemColorclipcolor, this, notifyFunction, signalColorclipcolorChanged);
  addItem( itemColorclipcolor, QStringLiteral( "colorclipcolor" ) );
  KConfigCompilerSignallingItem  *itemShowSubtitles;
  KConfigSkeleton::ItemBool  *innerItemShowSubtitles;
  innerItemShowSubtitles = new KConfigSkeleton::ItemBool( currentGroup(), QStringLiteral( "showSubtitles" ), mShowSubtitles, false );
  itemShowSubtitles = new KConfigCompilerSignallingItem(innerItemShowSubtitles, this, notifyFunction, signalShowSubtitlesChanged);
  addItem( itemShowSubtitles, QStringLiteral( "showSubtitles" ) );
  KConfigCompilerSignallingItem  *itemSubtitleEditFontSize;
  KConfigSkeleton::ItemDouble  *innerItemSubtitleEditFontSize;
  innerItemSubtitleEditFontSize = new KConfigSkeleton::ItemDouble( currentGroup(), QStringLiteral( "subtitleEditFontSize" ), mSubtitleEditFontSize, 0 );
  itemSubtitleEditFontSize = new KConfigCompilerSignallingItem(innerItemSubtitleEditFontSize, this, notifyFunction, signalSubtitleEditFontSizeChanged);
  addItem( itemSubtitleEditFontSize, QStringLiteral( "subtitleEditFontSize" ) );
  KConfigCompilerSignallingItem  *itemThumbColor1;
  KConfigSkeleton::ItemColor  *innerItemThumbColor1;
  innerItemThumbColor1 = new KConfigSkeleton::ItemColor( currentGroup(), QStringLiteral( "thumbColor1" ), mThumbColor1, QColor( "#2ac1a0" ) );
  itemThumbColor1 = new KConfigCompilerSignallingItem(innerItemThumbColor1, this, notifyFunction, signalThumbColor1Changed);
  addItem( itemThumbColor1, QStringLiteral( "thumbColor1" ) );
  KConfigCompilerSignallingItem  *itemThumbColor2;
  KConfigSkeleton::ItemColor  *innerItemThumbColor2;
  innerItemThumbColor2 = new KConfigSkeleton::ItemColor( currentGroup(), QStringLiteral( "thumbColor2" ), mThumbColor2, QColor( "#2ed172" ) );
  itemThumbColor2 = new KConfigCompilerSignallingItem(innerItemThumbColor2, this, notifyFunction, signalThumbColor2Changed);
  addItem( itemThumbColor2, QStringLiteral( "thumbColor2" ) );
  KConfigCompilerSignallingItem  *itemOverlayColor;
  KConfigSkeleton::ItemColor  *innerItemOverlayColor;
  innerItemOverlayColor = new KConfigSkeleton::ItemColor( currentGroup(), QStringLiteral( "overlayColor" ), mOverlayColor, QColor( "#00ffff" ) );
  itemOverlayColor = new KConfigCompilerSignallingItem(innerItemOverlayColor, this, notifyFunction, signalOverlayColorChanged);
  addItem( itemOverlayColor, QStringLiteral( "overlayColor" ) );
  KConfigCompilerSignallingItem  *itemSafeColor;
  KConfigSkeleton::ItemColor  *innerItemSafeColor;
  innerItemSafeColor = new KConfigSkeleton::ItemColor( currentGroup(), QStringLiteral( "safeColor" ), mSafeColor, QColor( "#ffcc00" ) );
  itemSafeColor = new KConfigCompilerSignallingItem(innerItemSafeColor, this, notifyFunction, signalSafeColorChanged);
  addItem( itemSafeColor, QStringLiteral( "safeColor" ) );
  KConfigCompilerSignallingItem  *itemDefaultrescalewidth;
  KConfigSkeleton::ItemInt  *innerItemDefaultrescalewidth;
  innerItemDefaultrescalewidth = new KConfigSkeleton::ItemInt( currentGroup(), QStringLiteral( "defaultrescalewidth" ), mDefaultrescalewidth, 320 );
  itemDefaultrescalewidth = new KConfigCompilerSignallingItem(innerItemDefaultrescalewidth, this, notifyFunction, signalDefaultrescalewidthChanged);
  addItem( itemDefaultrescalewidth, QStringLiteral( "defaultrescalewidth" ) );
  KConfigCompilerSignallingItem  *itemDefaultrescaleheight;
  KConfigSkeleton::ItemInt  *innerItemDefaultrescaleheight;
  innerItemDefaultrescaleheight = new KConfigSkeleton::ItemInt( currentGroup(), QStringLiteral( "defaultrescaleheight" ), mDefaultrescaleheight, 240 );
  itemDefaultrescaleheight = new KConfigCompilerSignallingItem(innerItemDefaultrescaleheight, this, notifyFunction, signalDefaultrescaleheightChanged);
  addItem( itemDefaultrescaleheight, QStringLiteral( "defaultrescaleheight" ) );
  KConfigCompilerSignallingItem  *itemSlideshowbymime;
  KConfigSkeleton::ItemBool  *innerItemSlideshowbymime;
  innerItemSlideshowbymime = new KConfigSkeleton::ItemBool( currentGroup(), QStringLiteral( "slideshowbymime" ), mSlideshowbymime, true );
  itemSlideshowbymime = new KConfigCompilerSignallingItem(innerItemSlideshowbymime, this, notifyFunction, signalSlideshowbymimeChanged);
  addItem( itemSlideshowbymime, QStringLiteral( "slideshowbymime" ) );
  KConfigCompilerSignallingItem  *itemSlideshowmimeextension;
  KConfigSkeleton::ItemString  *innerItemSlideshowmimeextension;
  innerItemSlideshowmimeextension = new KConfigSkeleton::ItemString( currentGroup(), QStringLiteral( "slideshowmimeextension" ), mSlideshowmimeextension );
  itemSlideshowmimeextension = new KConfigCompilerSignallingItem(innerItemSlideshowmimeextension, this, notifyFunction, signalSlideshowmimeextensionChanged);
  addItem( itemSlideshowmimeextension, QStringLiteral( "slideshowmimeextension" ) );
  KConfigCompilerSignallingItem  *itemMonitorscene_directupdate;
  KConfigSkeleton::ItemBool  *innerItemMonitorscene_directupdate;
  innerItemMonitorscene_directupdate = new KConfigSkeleton::ItemBool( currentGroup(), QStringLiteral( "monitorscene_directupdate" ), mMonitorscene_directupdate, false );
  itemMonitorscene_directupdate = new KConfigCompilerSignallingItem(innerItemMonitorscene_directupdate, this, notifyFunction, signalMonitorscene_directupdateChanged);
  addItem( itemMonitorscene_directupdate, QStringLiteral( "monitorscene_directupdate" ) );
  KConfigCompilerSignallingItem  *itemAnalyse_stopmotion;
  KConfigSkeleton::ItemBool  *innerItemAnalyse_stopmotion;
  innerItemAnalyse_stopmotion = new KConfigSkeleton::ItemBool( currentGroup(), QStringLiteral( "analyse_stopmotion" ), mAnalyse_stopmotion, false );
  itemAnalyse_stopmotion = new KConfigCompilerSignallingItem(innerItemAnalyse_stopmotion, this, notifyFunction, signalAnalyse_stopmotionChanged);
  addItem( itemAnalyse_stopmotion, QStringLiteral( "analyse_stopmotion" ) );
  KConfigCompilerSignallingItem  *itemEnableaudiospectrum;
  KConfigSkeleton::ItemBool  *innerItemEnableaudiospectrum;
  innerItemEnableaudiospectrum = new KConfigSkeleton::ItemBool( currentGroup(), QStringLiteral( "enableaudiospectrum" ), mEnableaudiospectrum, true );
  itemEnableaudiospectrum = new KConfigCompilerSignallingItem(innerItemEnableaudiospectrum, this, notifyFunction, signalEnableaudiospectrumChanged);
  addItem( itemEnableaudiospectrum, QStringLiteral( "enableaudiospectrum" ) );
  KConfigCompilerSignallingItem  *itemShowstopmotionthumbs;
  KConfigSkeleton::ItemBool  *innerItemShowstopmotionthumbs;
  innerItemShowstopmotionthumbs = new KConfigSkeleton::ItemBool( currentGroup(), QStringLiteral( "showstopmotionthumbs" ), mShowstopmotionthumbs, true );
  itemShowstopmotionthumbs = new KConfigCompilerSignallingItem(innerItemShowstopmotionthumbs, this, notifyFunction, signalShowstopmotionthumbsChanged);
  addItem( itemShowstopmotionthumbs, QStringLiteral( "showstopmotionthumbs" ) );
  KConfigCompilerSignallingItem  *itemCaptureinterval;
  KConfigSkeleton::ItemInt  *innerItemCaptureinterval;
  innerItemCaptureinterval = new KConfigSkeleton::ItemInt( currentGroup(), QStringLiteral( "captureinterval" ), mCaptureinterval, 5 );
  itemCaptureinterval = new KConfigCompilerSignallingItem(innerItemCaptureinterval, this, notifyFunction, signalCaptureintervalChanged);
  addItem( itemCaptureinterval, QStringLiteral( "captureinterval" ) );
  KConfigCompilerSignallingItem  *itemSm_notifytime;
  KConfigSkeleton::ItemInt  *innerItemSm_notifytime;
  innerItemSm_notifytime = new KConfigSkeleton::ItemInt( currentGroup(), QStringLiteral( "sm_notifytime" ), mSm_notifytime, 3 );
  itemSm_notifytime = new KConfigCompilerSignallingItem(innerItemSm_notifytime, this, notifyFunction, signalSm_notifytimeChanged);
  addItem( itemSm_notifytime, QStringLiteral( "sm_notifytime" ) );
  KConfigCompilerSignallingItem  *itemSm_prenotify;
  KConfigSkeleton::ItemBool  *innerItemSm_prenotify;
  innerItemSm_prenotify = new KConfigSkeleton::ItemBool( currentGroup(), QStringLiteral( "sm_prenotify" ), mSm_prenotify, false );
  itemSm_prenotify = new KConfigCompilerSignallingItem(innerItemSm_prenotify, this, notifyFunction, signalSm_prenotifyChanged);
  addItem( itemSm_prenotify, QStringLiteral( "sm_prenotify" ) );
  KConfigCompilerSignallingItem  *itemSm_loop;
  KConfigSkeleton::ItemBool  *innerItemSm_loop;
  innerItemSm_loop = new KConfigSkeleton::ItemBool( currentGroup(), QStringLiteral( "sm_loop" ), mSm_loop, false );
  itemSm_loop = new KConfigCompilerSignallingItem(innerItemSm_loop, this, notifyFunction, signalSm_loopChanged);
  addItem( itemSm_loop, QStringLiteral( "sm_loop" ) );
  KConfigCompilerSignallingItem  *itemSm_playsound;
  KConfigSkeleton::ItemBool  *innerItemSm_playsound;
  innerItemSm_playsound = new KConfigSkeleton::ItemBool( currentGroup(), QStringLiteral( "sm_playsound" ), mSm_playsound, false );
  itemSm_playsound = new KConfigCompilerSignallingItem(innerItemSm_playsound, this, notifyFunction, signalSm_playsoundChanged);
  addItem( itemSm_playsound, QStringLiteral( "sm_playsound" ) );
  KConfigCompilerSignallingItem  *itemSm_framesplayback;
  KConfigSkeleton::ItemInt  *innerItemSm_framesplayback;
  innerItemSm_framesplayback = new KConfigSkeleton::ItemInt( currentGroup(), QStringLiteral( "sm_framesplayback" ), mSm_framesplayback, 10 );
  itemSm_framesplayback = new KConfigCompilerSignallingItem(innerItemSm_framesplayback, this, notifyFunction, signalSm_framesplaybackChanged);
  addItem( itemSm_framesplayback, QStringLiteral( "sm_framesplayback" ) );
  KConfigCompilerSignallingItem  *itemStopmotioneffect;
  KConfigSkeleton::ItemInt  *innerItemStopmotioneffect;
  innerItemStopmotioneffect = new KConfigSkeleton::ItemInt( currentGroup(), QStringLiteral( "stopmotioneffect" ), mStopmotioneffect, 0 );
  itemStopmotioneffect = new KConfigCompilerSignallingItem(innerItemStopmotioneffect, this, notifyFunction, signalStopmotioneffectChanged);
  addItem( itemStopmotioneffect, QStringLiteral( "stopmotioneffect" ) );
  KConfigCompilerSignallingItem  *itemOnmonitoreffects_cornersshowlines;
  KConfigSkeleton::ItemBool  *innerItemOnmonitoreffects_cornersshowlines;
  innerItemOnmonitoreffects_cornersshowlines = new KConfigSkeleton::ItemBool( currentGroup(), QStringLiteral( "onmonitoreffects_cornersshowlines" ), mOnmonitoreffects_cornersshowlines, false );
  itemOnmonitoreffects_cornersshowlines = new KConfigCompilerSignallingItem(innerItemOnmonitoreffects_cornersshowlines, this, notifyFunction, signalOnmonitoreffects_cornersshowlinesChanged);
  addItem( itemOnmonitoreffects_cornersshowlines, QStringLiteral( "onmonitoreffects_cornersshowlines" ) );
  KConfigCompilerSignallingItem  *itemOnmonitoreffects_geometryshowprevious;
  KConfigSkeleton::ItemBool  *innerItemOnmonitoreffects_geometryshowprevious;
  innerItemOnmonitoreffects_geometryshowprevious = new KConfigSkeleton::ItemBool( currentGroup(), QStringLiteral( "onmonitoreffects_geometryshowprevious" ), mOnmonitoreffects_geometryshowprevious, false );
  itemOnmonitoreffects_geometryshowprevious = new KConfigCompilerSignallingItem(innerItemOnmonitoreffects_geometryshowprevious, this, notifyFunction, signalOnmonitoreffects_geometryshowpreviousChanged);
  addItem( itemOnmonitoreffects_geometryshowprevious, QStringLiteral( "onmonitoreffects_geometryshowprevious" ) );
  KConfigCompilerSignallingItem  *itemOnmonitoreffects_geometryshowpath;
  KConfigSkeleton::ItemBool  *innerItemOnmonitoreffects_geometryshowpath;
  innerItemOnmonitoreffects_geometryshowpath = new KConfigSkeleton::ItemBool( currentGroup(), QStringLiteral( "onmonitoreffects_geometryshowpath" ), mOnmonitoreffects_geometryshowpath, true );
  itemOnmonitoreffects_geometryshowpath = new KConfigCompilerSignallingItem(innerItemOnmonitoreffects_geometryshowpath, this, notifyFunction, signalOnmonitoreffects_geometryshowpathChanged);
  addItem( itemOnmonitoreffects_geometryshowpath, QStringLiteral( "onmonitoreffects_geometryshowpath" ) );
  KConfigCompilerSignallingItem  *itemOnmonitoreffects_cornersshowcontrols;
  KConfigSkeleton::ItemBool  *innerItemOnmonitoreffects_cornersshowcontrols;
  innerItemOnmonitoreffects_cornersshowcontrols = new KConfigSkeleton::ItemBool( currentGroup(), QStringLiteral( "onmonitoreffects_cornersshowcontrols" ), mOnmonitoreffects_cornersshowcontrols, false );
  itemOnmonitoreffects_cornersshowcontrols = new KConfigCompilerSignallingItem(innerItemOnmonitoreffects_cornersshowcontrols, this, notifyFunction, signalOnmonitoreffects_cornersshowcontrolsChanged);
  addItem( itemOnmonitoreffects_cornersshowcontrols, QStringLiteral( "onmonitoreffects_cornersshowcontrols" ) );
  KConfigCompilerSignallingItem  *itemProjectloading_avformatnovalidate;
  KConfigSkeleton::ItemBool  *innerItemProjectloading_avformatnovalidate;
  innerItemProjectloading_avformatnovalidate = new KConfigSkeleton::ItemBool( currentGroup(), QStringLiteral( "projectloading_avformatnovalidate" ), mProjectloading_avformatnovalidate, false );
  itemProjectloading_avformatnovalidate = new KConfigCompilerSignallingItem(innerItemProjectloading_avformatnovalidate, this, notifyFunction, signalProjectloading_avformatnovalidateChanged);
  addItem( itemProjectloading_avformatnovalidate, QStringLiteral( "projectloading_avformatnovalidate" ) );
  KConfigCompilerSignallingItem  *itemMonitor_audio;
  KConfigSkeleton::ItemBool  *innerItemMonitor_audio;
  innerItemMonitor_audio = new KConfigSkeleton::ItemBool( currentGroup(), QStringLiteral( "monitor_audio" ), mMonitor_audio, true );
  itemMonitor_audio = new KConfigCompilerSignallingItem(innerItemMonitor_audio, this, notifyFunction, signalMonitor_audioChanged);
  addItem( itemMonitor_audio, QStringLiteral( "monitor_audio" ) );
  KConfigCompilerSignallingItem  *itemEnable_recording_preview;
  KConfigSkeleton::ItemBool  *innerItemEnable_recording_preview;
  innerItemEnable_recording_preview = new KConfigSkeleton::ItemBool( currentGroup(), QStringLiteral( "enable_recording_preview" ), mEnable_recording_preview, true );
  itemEnable_recording_preview = new KConfigCompilerSignallingItem(innerItemEnable_recording_preview, this, notifyFunction, signalEnable_recording_previewChanged);
  addItem( itemEnable_recording_preview, QStringLiteral( "enable_recording_preview" ) );
  KConfigCompilerSignallingItem  *itemAdd_new_clip;
  KConfigSkeleton::ItemBool  *innerItemAdd_new_clip;
  innerItemAdd_new_clip = new KConfigSkeleton::ItemBool( currentGroup(), QStringLiteral( "add_new_clip" ), mAdd_new_clip, true );
  itemAdd_new_clip = new KConfigCompilerSignallingItem(innerItemAdd_new_clip, this, notifyFunction, signalAdd_new_clipChanged);
  addItem( itemAdd_new_clip, QStringLiteral( "add_new_clip" ) );
  KConfigCompilerSignallingItem  *itemAdd_new_clip_to_folder;
  KConfigSkeleton::ItemBool  *innerItemAdd_new_clip_to_folder;
  innerItemAdd_new_clip_to_folder = new KConfigSkeleton::ItemBool( currentGroup(), QStringLiteral( "add_new_clip_to_folder" ), mAdd_new_clip_to_folder, true );
  itemAdd_new_clip_to_folder = new KConfigCompilerSignallingItem(innerItemAdd_new_clip_to_folder, this, notifyFunction, signalAdd_new_clip_to_folderChanged);
  addItem( itemAdd_new_clip_to_folder, QStringLiteral( "add_new_clip_to_folder" ) );
  KConfigCompilerSignallingItem  *itemDefault_marker_type;
  KConfigSkeleton::ItemInt  *innerItemDefault_marker_type;
  innerItemDefault_marker_type = new KConfigSkeleton::ItemInt( currentGroup(), QStringLiteral( "default_marker_type" ), mDefault_marker_type, 0 );
  itemDefault_marker_type = new KConfigCompilerSignallingItem(innerItemDefault_marker_type, this, notifyFunction, signalDefault_marker_typeChanged);
  addItem( itemDefault_marker_type, QStringLiteral( "default_marker_type" ) );
  KConfigCompilerSignallingItem  *itemMltdeinterlacer;
  KConfigSkeleton::ItemString  *innerItemMltdeinterlacer;
  innerItemMltdeinterlacer = new KConfigSkeleton::ItemString( currentGroup(), QStringLiteral( "mltdeinterlacer" ), mMltdeinterlacer, QStringLiteral( "onefield" ) );
  itemMltdeinterlacer = new KConfigCompilerSignallingItem(innerItemMltdeinterlacer, this, notifyFunction, signalMltdeinterlacerChanged);
  addItem( itemMltdeinterlacer, QStringLiteral( "mltdeinterlacer" ) );
  KConfigCompilerSignallingItem  *itemMltinterpolation;
  KConfigSkeleton::ItemString  *innerItemMltinterpolation;
  innerItemMltinterpolation = new KConfigSkeleton::ItemString( currentGroup(), QStringLiteral( "mltinterpolation" ), mMltinterpolation, QStringLiteral( "nearest" ) );
  itemMltinterpolation = new KConfigCompilerSignallingItem(innerItemMltinterpolation, this, notifyFunction, signalMltinterpolationChanged);
  addItem( itemMltinterpolation, QStringLiteral( "mltinterpolation" ) );
  QStringList defaultfavorite_effects;
  defaultfavorite_effects.append( QString::fromUtf8( "volume" ) );
  defaultfavorite_effects.append( QString::fromUtf8( "lift_gamma_gain" ) );
  defaultfavorite_effects.append( QString::fromUtf8( "qtblend" ) );

  KConfigCompilerSignallingItem  *itemFavorite_effects;
  KConfigSkeleton::ItemStringList  *innerItemFavorite_effects;
  innerItemFavorite_effects = new KConfigSkeleton::ItemStringList( currentGroup(), QStringLiteral( "favorite_effects" ), mFavorite_effects, defaultfavorite_effects );
  itemFavorite_effects = new KConfigCompilerSignallingItem(innerItemFavorite_effects, this, notifyFunction, signalFavorite_effectsChanged);
  addItem( itemFavorite_effects, QStringLiteral( "favorite_effects" ) );
  QStringList defaultfavorite_transitions;
  defaultfavorite_transitions.append( QString::fromUtf8( "wipe" ) );
  defaultfavorite_transitions.append( QString::fromUtf8( "qtblend" ) );

  KConfigCompilerSignallingItem  *itemFavorite_transitions;
  KConfigSkeleton::ItemStringList  *innerItemFavorite_transitions;
  innerItemFavorite_transitions = new KConfigSkeleton::ItemStringList( currentGroup(), QStringLiteral( "favorite_transitions" ), mFavorite_transitions, defaultfavorite_transitions );
  itemFavorite_transitions = new KConfigCompilerSignallingItem(innerItemFavorite_transitions, this, notifyFunction, signalFavorite_transitionsChanged);
  addItem( itemFavorite_transitions, QStringLiteral( "favorite_transitions" ) );
  KConfigCompilerSignallingItem  *itemSelected_effecttab;
  KConfigSkeleton::ItemInt  *innerItemSelected_effecttab;
  innerItemSelected_effecttab = new KConfigSkeleton::ItemInt( currentGroup(), QStringLiteral( "selected_effecttab" ), mSelected_effecttab, 0 );
  itemSelected_effecttab = new KConfigCompilerSignallingItem(innerItemSelected_effecttab, this, notifyFunction, signalSelected_effecttabChanged);
  addItem( itemSelected_effecttab, QStringLiteral( "selected_effecttab" ) );
  KConfigCompilerSignallingItem  *itemEffectViewAsIcon;
  KConfigSkeleton::ItemBool  *innerItemEffectViewAsIcon;
  innerItemEffectViewAsIcon = new KConfigSkeleton::ItemBool( currentGroup(), QStringLiteral( "effectViewAsIcon" ), mEffectViewAsIcon, false );
  itemEffectViewAsIcon = new KConfigCompilerSignallingItem(innerItemEffectViewAsIcon, this, notifyFunction, signalEffectViewAsIconChanged);
  addItem( itemEffectViewAsIcon, QStringLiteral( "effectViewAsIcon" ) );
  KConfigCompilerSignallingItem  *itemTransitionViewAsIcon;
  KConfigSkeleton::ItemBool  *innerItemTransitionViewAsIcon;
  innerItemTransitionViewAsIcon = new KConfigSkeleton::ItemBool( currentGroup(), QStringLiteral( "transitionViewAsIcon" ), mTransitionViewAsIcon, false );
  itemTransitionViewAsIcon = new KConfigCompilerSignallingItem(innerItemTransitionViewAsIcon, this, notifyFunction, signalTransitionViewAsIconChanged);
  addItem( itemTransitionViewAsIcon, QStringLiteral( "transitionViewAsIcon" ) );

  setCurrentGroup( QStringLiteral( "startup" ) );

  KConfigCompilerSignallingItem  *itemForce_breeze;
  KConfigSkeleton::ItemBool  *innerItemForce_breeze;
  innerItemForce_breeze = new KConfigSkeleton::ItemBool( currentGroup(), QStringLiteral( "force_breeze" ), mForce_breeze, false );
  itemForce_breeze = new KConfigCompilerSignallingItem(innerItemForce_breeze, this, notifyFunction, signalForce_breezeChanged);
  addItem( itemForce_breeze, QStringLiteral( "force_breeze" ) );
  KConfigCompilerSignallingItem  *itemUse_dark_breeze;
  KConfigSkeleton::ItemBool  *innerItemUse_dark_breeze;
  innerItemUse_dark_breeze = new KConfigSkeleton::ItemBool( currentGroup(), QStringLiteral( "use_dark_breeze" ), mUse_dark_breeze, false );
  itemUse_dark_breeze = new KConfigCompilerSignallingItem(innerItemUse_dark_breeze, this, notifyFunction, signalUse_dark_breezeChanged);
  addItem( itemUse_dark_breeze, QStringLiteral( "use_dark_breeze" ) );
  KConfigCompilerSignallingItem  *itemShowWelcome;
  KConfigSkeleton::ItemBool  *innerItemShowWelcome;
  innerItemShowWelcome = new KConfigSkeleton::ItemBool( currentGroup(), QStringLiteral( "showWelcome" ), mShowWelcome, true );
  itemShowWelcome = new KConfigCompilerSignallingItem(innerItemShowWelcome, this, notifyFunction, signalShowWelcomeChanged);
  addItem( itemShowWelcome, QStringLiteral( "showWelcome" ) );
  KConfigCompilerSignallingItem  *itemLastSeenVersionMajor;
  KConfigSkeleton::ItemInt  *innerItemLastSeenVersionMajor;
  innerItemLastSeenVersionMajor = new KConfigSkeleton::ItemInt( currentGroup(), QStringLiteral( "lastSeenVersionMajor" ), mLastSeenVersionMajor, 0 );
  itemLastSeenVersionMajor = new KConfigCompilerSignallingItem(innerItemLastSeenVersionMajor, this, notifyFunction, signalLastSeenVersionMajorChanged);
  addItem( itemLastSeenVersionMajor, QStringLiteral( "lastSeenVersionMajor" ) );
  KConfigCompilerSignallingItem  *itemLastSeenVersionMinor;
  KConfigSkeleton::ItemInt  *innerItemLastSeenVersionMinor;
  innerItemLastSeenVersionMinor = new KConfigSkeleton::ItemInt( currentGroup(), QStringLiteral( "lastSeenVersionMinor" ), mLastSeenVersionMinor, 0 );
  itemLastSeenVersionMinor = new KConfigCompilerSignallingItem(innerItemLastSeenVersionMinor, this, notifyFunction, signalLastSeenVersionMinorChanged);
  addItem( itemLastSeenVersionMinor, QStringLiteral( "lastSeenVersionMinor" ) );
  KConfigCompilerSignallingItem  *itemLastSeenVersionMicro;
  KConfigSkeleton::ItemInt  *innerItemLastSeenVersionMicro;
  innerItemLastSeenVersionMicro = new KConfigSkeleton::ItemInt( currentGroup(), QStringLiteral( "lastSeenVersionMicro" ), mLastSeenVersionMicro, 0 );
  itemLastSeenVersionMicro = new KConfigCompilerSignallingItem(innerItemLastSeenVersionMicro, this, notifyFunction, signalLastSeenVersionMicroChanged);
  addItem( itemLastSeenVersionMicro, QStringLiteral( "lastSeenVersionMicro" ) );

  setCurrentGroup( QStringLiteral( "effects" ) );

  KConfigCompilerSignallingItem  *itemLock_ratio;
  KConfigSkeleton::ItemBool  *innerItemLock_ratio;
  innerItemLock_ratio = new KConfigSkeleton::ItemBool( currentGroup(), QStringLiteral( "lock_ratio" ), mLock_ratio, true );
  itemLock_ratio = new KConfigCompilerSignallingItem(innerItemLock_ratio, this, notifyFunction, signalLock_ratioChanged);
  addItem( itemLock_ratio, QStringLiteral( "lock_ratio" ) );

  setCurrentGroup( QStringLiteral( "titles" ) );

  KConfigCompilerSignallingItem  *itemSelected_template;
  KConfigSkeleton::ItemString  *innerItemSelected_template;
  innerItemSelected_template = new KConfigSkeleton::ItemString( currentGroup(), QStringLiteral( "selected_template" ), mSelected_template );
  itemSelected_template = new KConfigCompilerSignallingItem(innerItemSelected_template, this, notifyFunction, signalSelected_templateChanged);
  addItem( itemSelected_template, QStringLiteral( "selected_template" ) );
  KConfigCompilerSignallingItem  *itemTitlerShowGuides;
  KConfigSkeleton::ItemBool  *innerItemTitlerShowGuides;
  innerItemTitlerShowGuides = new KConfigSkeleton::ItemBool( currentGroup(), QStringLiteral( "titlerShowGuides" ), mTitlerShowGuides, false );
  itemTitlerShowGuides = new KConfigCompilerSignallingItem(innerItemTitlerShowGuides, this, notifyFunction, signalTitlerShowGuidesChanged);
  addItem( itemTitlerShowGuides, QStringLiteral( "titlerShowGuides" ) );
  KConfigCompilerSignallingItem  *itemTitlerVersion;
  KConfigSkeleton::ItemInt  *innerItemTitlerVersion;
  innerItemTitlerVersion = new KConfigSkeleton::ItemInt( currentGroup(), QStringLiteral( "titlerVersion" ), mTitlerVersion, 0 );
  itemTitlerVersion = new KConfigCompilerSignallingItem(innerItemTitlerVersion, this, notifyFunction, signalTitlerVersionChanged);
  addItem( itemTitlerVersion, QStringLiteral( "titlerVersion" ) );
  KConfigCompilerSignallingItem  *itemTitlerHGuides;
  KConfigSkeleton::ItemInt  *innerItemTitlerHGuides;
  innerItemTitlerHGuides = new KConfigSkeleton::ItemInt( currentGroup(), QStringLiteral( "titlerHGuides" ), mTitlerHGuides, 2 );
  itemTitlerHGuides = new KConfigCompilerSignallingItem(innerItemTitlerHGuides, this, notifyFunction, signalTitlerHGuidesChanged);
  addItem( itemTitlerHGuides, QStringLiteral( "titlerHGuides" ) );
  KConfigCompilerSignallingItem  *itemTitlerVGuides;
  KConfigSkeleton::ItemInt  *innerItemTitlerVGuides;
  innerItemTitlerVGuides = new KConfigSkeleton::ItemInt( currentGroup(), QStringLiteral( "titlerVGuides" ), mTitlerVGuides, 3 );
  itemTitlerVGuides = new KConfigCompilerSignallingItem(innerItemTitlerVGuides, this, notifyFunction, signalTitlerVGuidesChanged);
  addItem( itemTitlerVGuides, QStringLiteral( "titlerVGuides" ) );
  KConfigCompilerSignallingItem  *itemTitleGuideColor;
  KConfigSkeleton::ItemColor  *innerItemTitleGuideColor;
  innerItemTitleGuideColor = new KConfigSkeleton::ItemColor( currentGroup(), QStringLiteral( "titleGuideColor" ), mTitleGuideColor, QColor( "#ff0000" ) );
  itemTitleGuideColor = new KConfigCompilerSignallingItem(innerItemTitleGuideColor, this, notifyFunction, signalTitleGuideColorChanged);
  addItem( itemTitleGuideColor, QStringLiteral( "titleGuideColor" ) );
  KConfigCompilerSignallingItem  *itemTitlerbg;
  KConfigSkeleton::ItemInt  *innerItemTitlerbg;
  innerItemTitlerbg = new KConfigSkeleton::ItemInt( currentGroup(), QStringLiteral( "titlerbg" ), mTitlerbg, 0 );
  itemTitlerbg = new KConfigCompilerSignallingItem(innerItemTitlerbg, this, notifyFunction, signalTitlerbgChanged);
  addItem( itemTitlerbg, QStringLiteral( "titlerbg" ) );
  KConfigCompilerSignallingItem  *itemTitlerShowbg;
  KConfigSkeleton::ItemBool  *innerItemTitlerShowbg;
  innerItemTitlerShowbg = new KConfigSkeleton::ItemBool( currentGroup(), QStringLiteral( "titlerShowbg" ), mTitlerShowbg, false );
  itemTitlerShowbg = new KConfigCompilerSignallingItem(innerItemTitlerShowbg, this, notifyFunction, signalTitlerShowbgChanged);
  addItem( itemTitlerShowbg, QStringLiteral( "titlerShowbg" ) );
  KConfigCompilerSignallingItem  *itemTitlerAlign;
  KConfigSkeleton::ItemInt  *innerItemTitlerAlign;
  innerItemTitlerAlign = new KConfigSkeleton::ItemInt( currentGroup(), QStringLiteral( "titlerAlign" ), mTitlerAlign, 0 );
  itemTitlerAlign = new KConfigCompilerSignallingItem(innerItemTitlerAlign, this, notifyFunction, signalTitlerAlignChanged);
  addItem( itemTitlerAlign, QStringLiteral( "titlerAlign" ) );

  setCurrentGroup( QStringLiteral( "sam" ) );

  KConfigCompilerSignallingItem  *itemSamModelFile;
  KConfigSkeleton::ItemString  *innerItemSamModelFile;
  innerItemSamModelFile = new KConfigSkeleton::ItemString( currentGroup(), QStringLiteral( "samModelFile" ), mSamModelFile );
  itemSamModelFile = new KConfigCompilerSignallingItem(innerItemSamModelFile, this, notifyFunction, signalSamModelFileChanged);
  addItem( itemSamModelFile, QStringLiteral( "samModelFile" ) );
  KConfigCompilerSignallingItem  *itemSam_offload_video;
  KConfigSkeleton::ItemBool  *innerItemSam_offload_video;
  innerItemSam_offload_video = new KConfigSkeleton::ItemBool( currentGroup(), QStringLiteral( "sam_offload_video" ), mSam_offload_video, false );
  itemSam_offload_video = new KConfigCompilerSignallingItem(innerItemSam_offload_video, this, notifyFunction, signalSam_offload_videoChanged);
  addItem( itemSam_offload_video, QStringLiteral( "sam_offload_video" ) );
  KConfigCompilerSignallingItem  *itemSam_system_python;
  KConfigSkeleton::ItemBool  *innerItemSam_system_python;
  innerItemSam_system_python = new KConfigSkeleton::ItemBool( currentGroup(), QStringLiteral( "sam_system_python" ), mSam_system_python, false );
  itemSam_system_python = new KConfigCompilerSignallingItem(innerItemSam_system_python, this, notifyFunction, signalSam_system_pythonChanged);
  addItem( itemSam_system_python, QStringLiteral( "sam_system_python" ) );
  KConfigCompilerSignallingItem  *itemSam_system_python_path;
  KConfigSkeleton::ItemPath  *innerItemSam_system_python_path;
  innerItemSam_system_python_path = new KConfigSkeleton::ItemPath( currentGroup(), QStringLiteral( "sam_system_python_path" ), mSam_system_python_path );
  itemSam_system_python_path = new KConfigCompilerSignallingItem(innerItemSam_system_python_path, this, notifyFunction, signalSam_system_python_pathChanged);
  addItem( itemSam_system_python_path, QStringLiteral( "sam_system_python_path" ) );
  KConfigCompilerSignallingItem  *itemMaskBorderWidth;
  KConfigSkeleton::ItemInt  *innerItemMaskBorderWidth;
  innerItemMaskBorderWidth = new KConfigSkeleton::ItemInt( currentGroup(), QStringLiteral( "maskBorderWidth" ), mMaskBorderWidth, 0 );
  itemMaskBorderWidth = new KConfigCompilerSignallingItem(innerItemMaskBorderWidth, this, notifyFunction, signalMaskBorderWidthChanged);
  addItem( itemMaskBorderWidth, QStringLiteral( "maskBorderWidth" ) );
  KConfigCompilerSignallingItem  *itemMaskBorderColor;
  KConfigSkeleton::ItemColor  *innerItemMaskBorderColor;
  innerItemMaskBorderColor = new KConfigSkeleton::ItemColor( currentGroup(), QStringLiteral( "maskBorderColor" ), mMaskBorderColor, QColor( "#64FF6464" ) );
  itemMaskBorderColor = new KConfigCompilerSignallingItem(innerItemMaskBorderColor, this, notifyFunction, signalMaskBorderColorChanged);
  addItem( itemMaskBorderColor, QStringLiteral( "maskBorderColor" ) );
  KConfigCompilerSignallingItem  *itemMaskColor;
  KConfigSkeleton::ItemColor  *innerItemMaskColor;
  innerItemMaskColor = new KConfigSkeleton::ItemColor( currentGroup(), QStringLiteral( "maskColor" ), mMaskColor, QColor( "#B4FF6464" ) );
  itemMaskColor = new KConfigCompilerSignallingItem(innerItemMaskColor, this, notifyFunction, signalMaskColorChanged);
  addItem( itemMaskColor, QStringLiteral( "maskColor" ) );

  setCurrentGroup( QStringLiteral( "speech" ) );

  KConfigCompilerSignallingItem  *itemSpeech_system_python;
  KConfigSkeleton::ItemBool  *innerItemSpeech_system_python;
  innerItemSpeech_system_python = new KConfigSkeleton::ItemBool( currentGroup(), QStringLiteral( "speech_system_python" ), mSpeech_system_python, false );
  itemSpeech_system_python = new KConfigCompilerSignallingItem(innerItemSpeech_system_python, this, notifyFunction, signalSpeech_system_pythonChanged);
  addItem( itemSpeech_system_python, QStringLiteral( "speech_system_python" ) );
  KConfigCompilerSignallingItem  *itemSpeech_system_python_path;
  KConfigSkeleton::ItemPath  *innerItemSpeech_system_python_path;
  innerItemSpeech_system_python_path = new KConfigSkeleton::ItemPath( currentGroup(), QStringLiteral( "speech_system_python_path" ), mSpeech_system_python_path );
  itemSpeech_system_python_path = new KConfigCompilerSignallingItem(innerItemSpeech_system_python_path, this, notifyFunction, signalSpeech_system_python_pathChanged);
  addItem( itemSpeech_system_python_path, QStringLiteral( "speech_system_python_path" ) );
  KConfigCompilerSignallingItem  *itemVosk_folder_path;
  KConfigSkeleton::ItemString  *innerItemVosk_folder_path;
  innerItemVosk_folder_path = new KConfigSkeleton::ItemString( currentGroup(), QStringLiteral( "vosk_folder_path" ), mVosk_folder_path );
  itemVosk_folder_path = new KConfigCompilerSignallingItem(innerItemVosk_folder_path, this, notifyFunction, signalVosk_folder_pathChanged);
  addItem( itemVosk_folder_path, QStringLiteral( "vosk_folder_path" ) );
  KConfigCompilerSignallingItem  *itemVosk_text_model;
  KConfigSkeleton::ItemString  *innerItemVosk_text_model;
  innerItemVosk_text_model = new KConfigSkeleton::ItemString( currentGroup(), QStringLiteral( "vosk_text_model" ), mVosk_text_model );
  itemVosk_text_model = new KConfigCompilerSignallingItem(innerItemVosk_text_model, this, notifyFunction, signalVosk_text_modelChanged);
  addItem( itemVosk_text_model, QStringLiteral( "vosk_text_model" ) );
  KConfigCompilerSignallingItem  *itemVosk_srt_model;
  KConfigSkeleton::ItemString  *innerItemVosk_srt_model;
  innerItemVosk_srt_model = new KConfigSkeleton::ItemString( currentGroup(), QStringLiteral( "vosk_srt_model" ), mVosk_srt_model );
  itemVosk_srt_model = new KConfigCompilerSignallingItem(innerItemVosk_srt_model, this, notifyFunction, signalVosk_srt_modelChanged);
  addItem( itemVosk_srt_model, QStringLiteral( "vosk_srt_model" ) );
  KConfigCompilerSignallingItem  *itemSpeech_zone;
  KConfigSkeleton::ItemBool  *innerItemSpeech_zone;
  innerItemSpeech_zone = new KConfigSkeleton::ItemBool( currentGroup(), QStringLiteral( "speech_zone" ), mSpeech_zone, true );
  itemSpeech_zone = new KConfigCompilerSignallingItem(innerItemSpeech_zone, this, notifyFunction, signalSpeech_zoneChanged);
  addItem( itemSpeech_zone, QStringLiteral( "speech_zone" ) );
  KConfigCompilerSignallingItem  *itemWhisperModel;
  KConfigSkeleton::ItemString  *innerItemWhisperModel;
  innerItemWhisperModel = new KConfigSkeleton::ItemString( currentGroup(), QStringLiteral( "whisperModel" ), mWhisperModel, QStringLiteral( "turbo" ) );
  itemWhisperModel = new KConfigCompilerSignallingItem(innerItemWhisperModel, this, notifyFunction, signalWhisperModelChanged);
  addItem( itemWhisperModel, QStringLiteral( "whisperModel" ) );
  KConfigCompilerSignallingItem  *itemWhisperInstalledModels;
  KConfigSkeleton::ItemStringList  *innerItemWhisperInstalledModels;
  innerItemWhisperInstalledModels = new KConfigSkeleton::ItemStringList( currentGroup(), QStringLiteral( "whisperInstalledModels" ), mWhisperInstalledModels );
  itemWhisperInstalledModels = new KConfigCompilerSignallingItem(innerItemWhisperInstalledModels, this, notifyFunction, signalWhisperInstalledModelsChanged);
  addItem( itemWhisperInstalledModels, QStringLiteral( "whisperInstalledModels" ) );
  QStringList defaultwhisperAvailableModels;
  defaultwhisperAvailableModels.append( QString::fromUtf8( "tiny.en=tiny.en.pt" ) );
  defaultwhisperAvailableModels.append( QString::fromUtf8( "tiny=tiny.pt" ) );
  defaultwhisperAvailableModels.append( QString::fromUtf8( "base.en=base.en.pt" ) );
  defaultwhisperAvailableModels.append( QString::fromUtf8( "base=base.pt" ) );
  defaultwhisperAvailableModels.append( QString::fromUtf8( "small.en=small.en.pt" ) );
  defaultwhisperAvailableModels.append( QString::fromUtf8( "small=small.pt" ) );
  defaultwhisperAvailableModels.append( QString::fromUtf8( "medium.en=medium.en.pt" ) );
  defaultwhisperAvailableModels.append( QString::fromUtf8( "medium=medium.pt" ) );
  defaultwhisperAvailableModels.append( QString::fromUtf8( "large-v1=large-v1.pt" ) );
  defaultwhisperAvailableModels.append( QString::fromUtf8( "large-v2=large-v2.pt" ) );
  defaultwhisperAvailableModels.append( QString::fromUtf8( "large-v3=large-v3.pt" ) );
  defaultwhisperAvailableModels.append( QString::fromUtf8( "large=large-v3.pt" ) );
  defaultwhisperAvailableModels.append( QString::fromUtf8( "large-v3-turbo=large-v3-turbo.pt" ) );
  defaultwhisperAvailableModels.append( QString::fromUtf8( "turbo=large-v3-turbo.pt" ) );

  KConfigCompilerSignallingItem  *itemWhisperAvailableModels;
  KConfigSkeleton::ItemStringList  *innerItemWhisperAvailableModels;
  innerItemWhisperAvailableModels = new KConfigSkeleton::ItemStringList( currentGroup(), QStringLiteral( "whisperAvailableModels" ), mWhisperAvailableModels, defaultwhisperAvailableModels );
  itemWhisperAvailableModels = new KConfigCompilerSignallingItem(innerItemWhisperAvailableModels, this, notifyFunction, signalWhisperAvailableModelsChanged);
  addItem( itemWhisperAvailableModels, QStringLiteral( "whisperAvailableModels" ) );
  KConfigCompilerSignallingItem  *itemWhisperAvailableModelsHash;
  KConfigSkeleton::ItemStringList  *innerItemWhisperAvailableModelsHash;
  innerItemWhisperAvailableModelsHash = new KConfigSkeleton::ItemStringList( currentGroup(), QStringLiteral( "whisperAvailableModelsHash" ), mWhisperAvailableModelsHash );
  itemWhisperAvailableModelsHash = new KConfigCompilerSignallingItem(innerItemWhisperAvailableModelsHash, this, notifyFunction, signalWhisperAvailableModelsHashChanged);
  addItem( itemWhisperAvailableModelsHash, QStringLiteral( "whisperAvailableModelsHash" ) );
  KConfigCompilerSignallingItem  *itemWhisperModelFolder;
  KConfigSkeleton::ItemString  *innerItemWhisperModelFolder;
  innerItemWhisperModelFolder = new KConfigSkeleton::ItemString( currentGroup(), QStringLiteral( "whisperModelFolder" ), mWhisperModelFolder );
  itemWhisperModelFolder = new KConfigCompilerSignallingItem(innerItemWhisperModelFolder, this, notifyFunction, signalWhisperModelFolderChanged);
  addItem( itemWhisperModelFolder, QStringLiteral( "whisperModelFolder" ) );
  KConfigCompilerSignallingItem  *itemWhisperLanguage;
  KConfigSkeleton::ItemString  *innerItemWhisperLanguage;
  innerItemWhisperLanguage = new KConfigSkeleton::ItemString( currentGroup(), QStringLiteral( "whisperLanguage" ), mWhisperLanguage );
  itemWhisperLanguage = new KConfigCompilerSignallingItem(innerItemWhisperLanguage, this, notifyFunction, signalWhisperLanguageChanged);
  addItem( itemWhisperLanguage, QStringLiteral( "whisperLanguage" ) );
  KConfigCompilerSignallingItem  *itemEnableSeamless;
  KConfigSkeleton::ItemBool  *innerItemEnableSeamless;
  innerItemEnableSeamless = new KConfigSkeleton::ItemBool( currentGroup(), QStringLiteral( "enableSeamless" ), mEnableSeamless, false );
  itemEnableSeamless = new KConfigCompilerSignallingItem(innerItemEnableSeamless, this, notifyFunction, signalEnableSeamlessChanged);
  addItem( itemEnableSeamless, QStringLiteral( "enableSeamless" ) );
  KConfigCompilerSignallingItem  *itemSrtSeamlessTranslate;
  KConfigSkeleton::ItemBool  *innerItemSrtSeamlessTranslate;
  innerItemSrtSeamlessTranslate = new KConfigSkeleton::ItemBool( currentGroup(), QStringLiteral( "srtSeamlessTranslate" ), mSrtSeamlessTranslate, false );
  itemSrtSeamlessTranslate = new KConfigCompilerSignallingItem(innerItemSrtSeamlessTranslate, this, notifyFunction, signalSrtSeamlessTranslateChanged);
  addItem( itemSrtSeamlessTranslate, QStringLiteral( "srtSeamlessTranslate" ) );
  KConfigCompilerSignallingItem  *itemSeamless_input;
  KConfigSkeleton::ItemString  *innerItemSeamless_input;
  innerItemSeamless_input = new KConfigSkeleton::ItemString( currentGroup(), QStringLiteral( "seamless_input" ), mSeamless_input );
  itemSeamless_input = new KConfigCompilerSignallingItem(innerItemSeamless_input, this, notifyFunction, signalSeamless_inputChanged);
  addItem( itemSeamless_input, QStringLiteral( "seamless_input" ) );
  KConfigCompilerSignallingItem  *itemSeamless_output;
  KConfigSkeleton::ItemString  *innerItemSeamless_output;
  innerItemSeamless_output = new KConfigSkeleton::ItemString( currentGroup(), QStringLiteral( "seamless_output" ), mSeamless_output );
  itemSeamless_output = new KConfigCompilerSignallingItem(innerItemSeamless_output, this, notifyFunction, signalSeamless_outputChanged);
  addItem( itemSeamless_output, QStringLiteral( "seamless_output" ) );
  KConfigCompilerSignallingItem  *itemWhisperMaxChars;
  KConfigSkeleton::ItemInt  *innerItemWhisperMaxChars;
  innerItemWhisperMaxChars = new KConfigSkeleton::ItemInt( currentGroup(), QStringLiteral( "whisperMaxChars" ), mWhisperMaxChars, 42 );
  itemWhisperMaxChars = new KConfigCompilerSignallingItem(innerItemWhisperMaxChars, this, notifyFunction, signalWhisperMaxCharsChanged);
  addItem( itemWhisperMaxChars, QStringLiteral( "whisperMaxChars" ) );
  KConfigCompilerSignallingItem  *itemSubtitleMode;
  KConfigSkeleton::ItemInt  *innerItemSubtitleMode;
  innerItemSubtitleMode = new KConfigSkeleton::ItemInt( currentGroup(), QStringLiteral( "subtitleMode" ), mSubtitleMode, 2 );
  itemSubtitleMode = new KConfigCompilerSignallingItem(innerItemSubtitleMode, this, notifyFunction, signalSubtitleModeChanged);
  addItem( itemSubtitleMode, QStringLiteral( "subtitleMode" ) );
  KConfigCompilerSignallingItem  *itemCutWhisperMaxChars;
  KConfigSkeleton::ItemBool  *innerItemCutWhisperMaxChars;
  innerItemCutWhisperMaxChars = new KConfigSkeleton::ItemBool( currentGroup(), QStringLiteral( "cutWhisperMaxChars" ), mCutWhisperMaxChars, true );
  itemCutWhisperMaxChars = new KConfigCompilerSignallingItem(innerItemCutWhisperMaxChars, this, notifyFunction, signalCutWhisperMaxCharsChanged);
  addItem( itemCutWhisperMaxChars, QStringLiteral( "cutWhisperMaxChars" ) );
  KConfigCompilerSignallingItem  *itemWhisperDevice;
  KConfigSkeleton::ItemString  *innerItemWhisperDevice;
  innerItemWhisperDevice = new KConfigSkeleton::ItemString( currentGroup(), QStringLiteral( "whisperDevice" ), mWhisperDevice, QStringLiteral( "cpu" ) );
  itemWhisperDevice = new KConfigCompilerSignallingItem(innerItemWhisperDevice, this, notifyFunction, signalWhisperDeviceChanged);
  addItem( itemWhisperDevice, QStringLiteral( "whisperDevice" ) );
  KConfigCompilerSignallingItem  *itemSamDevice;
  KConfigSkeleton::ItemString  *innerItemSamDevice;
  innerItemSamDevice = new KConfigSkeleton::ItemString( currentGroup(), QStringLiteral( "samDevice" ), mSamDevice, QStringLiteral( "cpu" ) );
  itemSamDevice = new KConfigCompilerSignallingItem(innerItemSamDevice, this, notifyFunction, signalSamDeviceChanged);
  addItem( itemSamDevice, QStringLiteral( "samDevice" ) );
  KConfigCompilerSignallingItem  *itemWhisperTranslate;
  KConfigSkeleton::ItemBool  *innerItemWhisperTranslate;
  innerItemWhisperTranslate = new KConfigSkeleton::ItemBool( currentGroup(), QStringLiteral( "whisperTranslate" ), mWhisperTranslate, false );
  itemWhisperTranslate = new KConfigCompilerSignallingItem(innerItemWhisperTranslate, this, notifyFunction, signalWhisperTranslateChanged);
  addItem( itemWhisperTranslate, QStringLiteral( "whisperTranslate" ) );
  KConfigCompilerSignallingItem  *itemWhisperDisableFP16;
  KConfigSkeleton::ItemBool  *innerItemWhisperDisableFP16;
  innerItemWhisperDisableFP16 = new KConfigSkeleton::ItemBool( currentGroup(), QStringLiteral( "whisperDisableFP16" ), mWhisperDisableFP16, false );
  itemWhisperDisableFP16 = new KConfigCompilerSignallingItem(innerItemWhisperDisableFP16, this, notifyFunction, signalWhisperDisableFP16Changed);
  addItem( itemWhisperDisableFP16, QStringLiteral( "whisperDisableFP16" ) );
  KConfigCompilerSignallingItem  *itemWhisperExtra;
  KConfigSkeleton::ItemString  *innerItemWhisperExtra;
  innerItemWhisperExtra = new KConfigSkeleton::ItemString( currentGroup(), QStringLiteral( "whisperExtra" ), mWhisperExtra );
  itemWhisperExtra = new KConfigCompilerSignallingItem(innerItemWhisperExtra, this, notifyFunction, signalWhisperExtraChanged);
  addItem( itemWhisperExtra, QStringLiteral( "whisperExtra" ) );
  KConfigCompilerSignallingItem  *itemSpeechEngine;
  KConfigSkeleton::ItemString  *innerItemSpeechEngine;
  innerItemSpeechEngine = new KConfigSkeleton::ItemString( currentGroup(), QStringLiteral( "speechEngine" ), mSpeechEngine, QStringLiteral( "whisper" ) );
  itemSpeechEngine = new KConfigCompilerSignallingItem(innerItemSpeechEngine, this, notifyFunction, signalSpeechEngineChanged);
  addItem( itemSpeechEngine, QStringLiteral( "speechEngine" ) );

  setCurrentGroup( QStringLiteral( "Media Browser" ) );

  KConfigCompilerSignallingItem  *itemMediaIconSize;
  KConfigSkeleton::ItemInt  *innerItemMediaIconSize;
  innerItemMediaIconSize = new KConfigSkeleton::ItemInt( currentGroup(), QStringLiteral( "mediaIconSize" ), mMediaIconSize, 16 );
  itemMediaIconSize = new KConfigCompilerSignallingItem(innerItemMediaIconSize, this, notifyFunction, signalMediaIconSizeChanged);
  addItem( itemMediaIconSize, QStringLiteral( "mediaIconSize" ) );
  KConfigCompilerSignallingItem  *itemMediaManagerPanelLayout;
  KConfigSkeleton::ItemString  *innerItemMediaManagerPanelLayout;
  innerItemMediaManagerPanelLayout = new KConfigSkeleton::ItemString( currentGroup(), QStringLiteral( "mediaManagerPanelLayout" ), mMediaManagerPanelLayout );
  itemMediaManagerPanelLayout = new KConfigCompilerSignallingItem(innerItemMediaManagerPanelLayout, this, notifyFunction, signalMediaManagerPanelLayoutChanged);
  addItem( itemMediaManagerPanelLayout, QStringLiteral( "mediaManagerPanelLayout" ) );
  KConfigCompilerSignallingItem  *itemMediaManagerPanelWidth;
  KConfigSkeleton::ItemInt  *innerItemMediaManagerPanelWidth;
  innerItemMediaManagerPanelWidth = new KConfigSkeleton::ItemInt( currentGroup(), QStringLiteral( "mediaManagerPanelWidth" ), mMediaManagerPanelWidth, 0 );
  itemMediaManagerPanelWidth = new KConfigCompilerSignallingItem(innerItemMediaManagerPanelWidth, this, notifyFunction, signalMediaManagerPanelWidthChanged);
  addItem( itemMediaManagerPanelWidth, QStringLiteral( "mediaManagerPanelWidth" ) );
  KConfigCompilerSignallingItem  *itemMediaBrowserAutoPlay;
  KConfigSkeleton::ItemBool  *innerItemMediaBrowserAutoPlay;
  innerItemMediaBrowserAutoPlay = new KConfigSkeleton::ItemBool( currentGroup(), QStringLiteral( "mediaBrowserAutoPlay" ), mMediaBrowserAutoPlay, false );
  itemMediaBrowserAutoPlay = new KConfigCompilerSignallingItem(innerItemMediaBrowserAutoPlay, this, notifyFunction, signalMediaBrowserAutoPlayChanged);
  addItem( itemMediaBrowserAutoPlay, QStringLiteral( "mediaBrowserAutoPlay" ) );
  KConfigCompilerSignallingItem  *itemMediaBrowserWithAudio;
  KConfigSkeleton::ItemBool  *innerItemMediaBrowserWithAudio;
  innerItemMediaBrowserWithAudio = new KConfigSkeleton::ItemBool( currentGroup(), QStringLiteral( "mediaBrowserWithAudio" ), mMediaBrowserWithAudio, true );
  itemMediaBrowserWithAudio = new KConfigCompilerSignallingItem(innerItemMediaBrowserWithAudio, this, notifyFunction, signalMediaBrowserWithAudioChanged);
  addItem( itemMediaBrowserWithAudio, QStringLiteral( "mediaBrowserWithAudio" ) );
  KConfigCompilerSignallingItem  *itemMediaDoubleClickImport;
  KConfigSkeleton::ItemBool  *innerItemMediaDoubleClickImport;
  innerItemMediaDoubleClickImport = new KConfigSkeleton::ItemBool( currentGroup(), QStringLiteral( "mediaDoubleClickImport" ), mMediaDoubleClickImport, true );
  itemMediaDoubleClickImport = new KConfigCompilerSignallingItem(innerItemMediaDoubleClickImport, this, notifyFunction, signalMediaDoubleClickImportChanged);
  addItem( itemMediaDoubleClickImport, QStringLiteral( "mediaDoubleClickImport" ) );
  KConfigCompilerSignallingItem  *itemMediaBrowserInlinePreview;
  KConfigSkeleton::ItemBool  *innerItemMediaBrowserInlinePreview;
  innerItemMediaBrowserInlinePreview = new KConfigSkeleton::ItemBool( currentGroup(), QStringLiteral( "mediaBrowserInlinePreview" ), mMediaBrowserInlinePreview, true );
  itemMediaBrowserInlinePreview = new KConfigCompilerSignallingItem(innerItemMediaBrowserInlinePreview, this, notifyFunction, signalMediaBrowserInlinePreviewChanged);
  addItem( itemMediaBrowserInlinePreview, QStringLiteral( "mediaBrowserInlinePreview" ) );
}

int KdenliveSettings::defaultBinSortingValue_helper()
{

  return 0;
}

int KdenliveSettings::defaultBinModeValue_helper()
{

  return 0;
}

int KdenliveSettings::defaultBin_zoomValue_helper()
{

  return 4;
}

bool KdenliveSettings::defaultHoverPreviewValue_helper()
{

  return false;
}

int KdenliveSettings::defaultBinsCountValue_helper()
{

  return 1;
}

int KdenliveSettings::defaultScenesplitthresholdValue_helper()
{

  return 30;
}

bool KdenliveSettings::defaultScenesplitmarkersValue_helper()
{

  return true;
}

bool KdenliveSettings::defaultScenesplitrangemarkersValue_helper()
{

  return true;
}

bool KdenliveSettings::defaultScenesplitsubclipsValue_helper()
{

  return false;
}

int KdenliveSettings::defaultCleanCacheMonthsValue_helper()
{

  return 6;
}

bool KdenliveSettings::defaultOpenlastprojectValue_helper()
{

  return false;
}

bool KdenliveSettings::defaultCrashrecoveryValue_helper()
{

  return true;
}

int KdenliveSettings::defaultAutosave_timeValue_helper()
{

  return 60;
}

int KdenliveSettings::defaultAutosave_opsValue_helper()
{

  return 25;
}

int KdenliveSettings::defaultTabpositionValue_helper()
{

  return 1;
}

bool KdenliveSettings::defaultCheckfirstprojectclipValue_helper()
{

  return true;
}

bool KdenliveSettings::defaultKeep_original_frame_sizeValue_helper()
{

  return false;
}

bool KdenliveSettings::defaultExportframe_usingsourceresValue_helper()
{

  return true;
}

QString KdenliveSettings::defaultColor_durationValue_helper()
{

  return QStringLiteral( "00:00:05:00" );
}

QString KdenliveSettings::defaultImage_durationValue_helper()
{

  return QStringLiteral( "00:00:05:00" );
}

QString KdenliveSettings::defaultSequence_durationValue_helper()
{

  return QStringLiteral( "00:00:00:01" );
}

QString KdenliveSettings::defaultFade_durationValue_helper()
{

  return QStringLiteral( "00:00:03:00" );
}

QString KdenliveSettings::defaultMix_durationValue_helper()
{

  return QStringLiteral( "00:00:01:00" );
}

QString KdenliveSettings::defaultSubtitle_durationValue_helper()
{

  return QStringLiteral( "00:00:05:00" );
}

bool KdenliveSettings::defaultAutoimagesequenceValue_helper()
{

  return false;
}

bool KdenliveSettings::defaultIgnoresubdirstructureValue_helper()
{

  return false;
}

bool KdenliveSettings::defaultDisableimagescalingValue_helper()
{

  return false;
}

bool KdenliveSettings::defaultAutomultistreamsValue_helper()
{

  return false;
}

bool KdenliveSettings::defaultUse_exiftoolValue_helper()
{

  return false;
}

bool KdenliveSettings::defaultUse_magicLanternValue_helper()
{

  return false;
}

QString KdenliveSettings::defaultTitle_durationValue_helper()
{

  return QStringLiteral( "00:00:05:00" );
}

QString KdenliveSettings::defaultTransition_durationValue_helper()
{

  return QStringLiteral( "00:00:03:00" );
}

bool KdenliveSettings::defaultEnableAssetsIncludeListValue_helper()
{

  return false;
}

bool KdenliveSettings::defaultShowEffectsInfoValue_helper()
{

  return false;
}

bool KdenliveSettings::defaultShowTransitionsInfoValue_helper()
{

  return false;
}

bool KdenliveSettings::defaultDisable_effect_parametersValue_helper()
{

  return true;
}

int KdenliveSettings::defaultOpengl_backendValue_helper()
{

  return 16;
}

int KdenliveSettings::defaultVideotracksValue_helper()
{

  return 2;
}

int KdenliveSettings::defaultAudiotracksValue_helper()
{

  return 2;
}

int KdenliveSettings::defaultAudio_channelsValue_helper()
{

  return 0;
}

bool KdenliveSettings::defaultEnableproxyValue_helper()
{

  return false;
}

bool KdenliveSettings::defaultExternalproxyValue_helper()
{

  return false;
}

bool KdenliveSettings::defaultGenerateproxyValue_helper()
{

  return false;
}

bool KdenliveSettings::defaultGenerateimageproxyValue_helper()
{

  return false;
}

int KdenliveSettings::defaultProxyminsizeValue_helper()
{

  return 1000;
}

int KdenliveSettings::defaultProxyimageminsizeValue_helper()
{

  return 2000;
}

int KdenliveSettings::defaultProxyimagesizeValue_helper()
{

  return 800;
}

int KdenliveSettings::defaultProxyscaleValue_helper()
{

  return 640;
}

bool KdenliveSettings::defaultEnforceLowerTrackCompositingValue_helper()
{

  return false;
}

int KdenliveSettings::defaultProxy_profileValue_helper()
{

  return 0;
}

int KdenliveSettings::defaultAlpha_profileValue_helper()
{

  return 0;
}

bool KdenliveSettings::defaultTranscodingReplaceValue_helper()
{

  return false;
}

int KdenliveSettings::defaultPreview_profileValue_helper()
{

  return 0;
}

bool KdenliveSettings::defaultParallelrenderValue_helper()
{

  return false;
}

QString KdenliveSettings::defaultRenderInterpValue_helper()
{

  return QStringLiteral( "bilinear" );
}

QString KdenliveSettings::defaultRenderDeinterlacerValue_helper()
{

  return QStringLiteral( "onefield" );
}

bool KdenliveSettings::defaultVaapiEnabledValue_helper()
{

  return false;
}

bool KdenliveSettings::defaultAmfEnabledValue_helper()
{

  return false;
}

bool KdenliveSettings::defaultNvScalingEnabledValue_helper()
{

  return false;
}

bool KdenliveSettings::defaultShowRenderTextParametersValue_helper()
{

  return false;
}

int KdenliveSettings::defaultHeaderwidthValue_helper()
{

  return 0;
}

int KdenliveSettings::defaultDefaultkeyframeinterpValue_helper()
{

  return 1;
}

int KdenliveSettings::defaultTimelinechunksValue_helper()
{

  return 25;
}

bool KdenliveSettings::defaultAutopreviewValue_helper()
{

  return false;
}

bool KdenliveSettings::defaultDraginprogressValue_helper()
{

  return false;
}

bool KdenliveSettings::defaultProxypreviewValue_helper()
{

  return true;
}

int KdenliveSettings::defaultMultistreamValue_helper()
{

  return 0;
}

bool KdenliveSettings::defaultMultistream_checktrackValue_helper()
{

  return true;
}

bool KdenliveSettings::defaultVideothumbnailsValue_helper()
{

  return true;
}

bool KdenliveSettings::defaultAudiothumbnailsValue_helper()
{

  return true;
}

int KdenliveSettings::defaultWaveformScalerValue_helper()
{

  return 1;
}

bool KdenliveSettings::defaultShowmarkersValue_helper()
{

  return true;
}

bool KdenliveSettings::defaultDisplayallchannelsValue_helper()
{

  return true;
}

bool KdenliveSettings::defaultNormalizechannelsValue_helper()
{

  return true;
}

bool KdenliveSettings::defaultAutotrackheightValue_helper()
{

  return false;
}

bool KdenliveSettings::defaultAutoscrollValue_helper()
{

  return true;
}

bool KdenliveSettings::defaultCenteredplayheadValue_helper()
{

  return false;
}

bool KdenliveSettings::defaultJumptostartValue_helper()
{

  return false;
}

bool KdenliveSettings::defaultPauseonseekValue_helper()
{

  return true;
}

bool KdenliveSettings::defaultSeekonaddeffectValue_helper()
{

  return false;
}

bool KdenliveSettings::defaultEnableBuiltInEffectsValue_helper()
{

  return false;
}

bool KdenliveSettings::defaultTenbitpipelineValue_helper()
{

  return false;
}

bool KdenliveSettings::defaultEffectsFilterValue_helper()
{

  return false;
}

bool KdenliveSettings::defaultTransitionsFilterValue_helper()
{

  return false;
}

bool KdenliveSettings::defaultScrollverticallyValue_helper()
{

  return false;
}

int KdenliveSettings::defaultTrackheightValue_helper()
{

  return 0;
}

int KdenliveSettings::defaultAudiotracksbelowValue_helper()
{

  return 1;
}

bool KdenliveSettings::defaultRaisepropsclipsValue_helper()
{

  return true;
}

bool KdenliveSettings::defaultRaisepropscompositionsValue_helper()
{

  return true;
}

bool KdenliveSettings::defaultRaisepropsmixesValue_helper()
{

  return true;
}

bool KdenliveSettings::defaultRaisepropstracksValue_helper()
{

  return true;
}

bool KdenliveSettings::defaultUiDebugModeValue_helper()
{

  return false;
}

bool KdenliveSettings::defaultGpu_accelValue_helper()
{

  return false;
}

bool KdenliveSettings::defaultAudio_scrubValue_helper()
{

  return true;
}

QString KdenliveSettings::defaultSdlAudioBackendValue_helper()
{

  return QStringLiteral( "sdl2_audio" );
}

int KdenliveSettings::defaultAudio_backendValue_helper()
{

  return 0;
}

QString KdenliveSettings::defaultAudiobackendValue_helper()
{

  return QStringLiteral( "sdl2_audio" );
}

uint KdenliveSettings::defaultAudio_driverValue_helper()
{

  return 0;
}

bool KdenliveSettings::defaultDisablereccountdownValue_helper()
{

  return false;
}

QColor KdenliveSettings::defaultWindow_backgroundValue_helper()
{

  return QColor( "#535353" );
}

bool KdenliveSettings::defaultShowMonitorGridValue_helper()
{

  return false;
}

int KdenliveSettings::defaultMonitorGridHValue_helper()
{

  return 100;
}

int KdenliveSettings::defaultMonitorGridVValue_helper()
{

  return 100;
}

QString KdenliveSettings::defaultMonitor_backgroundValue_helper()
{

  return QStringLiteral( "black" );
}

bool KdenliveSettings::defaultMonitor_progressiveValue_helper()
{

  return true;
}

int KdenliveSettings::defaultVolumeValue_helper()
{

  return 100;
}

bool KdenliveSettings::defaultMonitor_dropframesValue_helper()
{

  return true;
}

bool KdenliveSettings::defaultExternal_displayValue_helper()
{

  return false;
}

int KdenliveSettings::defaultBlackmagic_output_deviceValue_helper()
{

  return 0;
}

bool KdenliveSettings::defaultPlay_monitor_on_clickValue_helper()
{

  return true;
}

bool KdenliveSettings::defaultMirrorMonitorOnFullscreenValue_helper()
{

  return false;
}

QStringList KdenliveSettings::defaultCompositingListValue_helper()
{
  QStringList defaultcompositingList;
  defaultcompositingList.append( QString::fromUtf8( "qtblend" ) );
  defaultcompositingList.append( QString::fromUtf8( "frei0r.cairoblend" ) );

  return defaultcompositingList;
}

int KdenliveSettings::defaultSubtitle_razor_modeValue_helper()
{

  return 0;
}

int KdenliveSettings::defaultProcessingthreadsValue_helper()
{

  return 4;
}

int KdenliveSettings::defaultProxythreadsValue_helper()
{

  return 2;
}

int KdenliveSettings::defaultEncodethreadsValue_helper()
{

  return 0;
}

QString KdenliveSettings::defaultCurrenttmpfolderValue_helper()
{

  return QStringLiteral( "/tmp/" );
}

int KdenliveSettings::defaultMaxcachesizeValue_helper()
{

  return 1024;
}

bool KdenliveSettings::defaultCheckForUpdateValue_helper()
{

  return true;
}

bool KdenliveSettings::defaultUsePowerManagementValue_helper()
{

  return true;
}

bool KdenliveSettings::defaultCustomprojectfolderValue_helper()
{

  return false;
}

bool KdenliveSettings::defaultSameprojectfolderValue_helper()
{

  return false;
}

int KdenliveSettings::defaultCapturetoprojectfolderValue_helper()
{

  return 1;
}

QString KdenliveSettings::defaultCapturefolderValue_helper()
{

  return QStringLiteral( "$HOME" );
}

bool KdenliveSettings::defaultLibrarytodefaultfolderValue_helper()
{

  return true;
}

int KdenliveSettings::defaultVideotodefaultfolderValue_helper()
{

  return 0;
}

bool KdenliveSettings::defaultNice_tasksValue_helper()
{

  return true;
}

double KdenliveSettings::defaultMultipleguidesintervalValue_helper()
{

  return 30;
}

bool KdenliveSettings::defaultGuidesShowThumbsValue_helper()
{

  return false;
}

bool KdenliveSettings::defaultGuidesSelectZoneValue_helper()
{

  return false;
}

QString KdenliveSettings::defaultDefaultaudiocaptureValue_helper()
{

  return QStringLiteral( "default:" );
}

int KdenliveSettings::defaultAudiocapturevolumeValue_helper()
{

  return 100;
}

int KdenliveSettings::defaultAudiocapturechannelsValue_helper()
{

  return 2;
}

int KdenliveSettings::defaultAudiocapturesamplerateValue_helper()
{

  return 48000;
}

int KdenliveSettings::defaultAudiocapturesampleformatValue_helper()
{

  return 2;
}

int KdenliveSettings::defaultDefaultcaptureValue_helper()
{

  return 0;
}

uint KdenliveSettings::defaultAlsachannelsValue_helper()
{

  return 2;
}

int KdenliveSettings::defaultGrab_profileValue_helper()
{

  return 0;
}

int KdenliveSettings::defaultGrab_capture_typeValue_helper()
{

  return 0;
}

bool KdenliveSettings::defaultGrab_follow_mouseValue_helper()
{

  return false;
}

int KdenliveSettings::defaultGrab_offsetxValue_helper()
{

  return 0;
}

int KdenliveSettings::defaultGrab_offsetyValue_helper()
{

  return 0;
}

int KdenliveSettings::defaultGrab_widthValue_helper()
{

  return 1280;
}

int KdenliveSettings::defaultGrab_heightValue_helper()
{

  return 720;
}

double KdenliveSettings::defaultGrab_fpsValue_helper()
{

  return 15.0;
}

bool KdenliveSettings::defaultGrab_hide_frameValue_helper()
{

  return true;
}

bool KdenliveSettings::defaultGrab_hide_mouseValue_helper()
{

  return false;
}

bool KdenliveSettings::defaultDecklink_device_foundValue_helper()
{

  return false;
}

uint KdenliveSettings::defaultDecklink_capturedeviceValue_helper()
{

  return 0;
}

int KdenliveSettings::defaultDecklink_profileValue_helper()
{

  return 0;
}

QString KdenliveSettings::defaultDecklink_filenameValue_helper()
{

  return QStringLiteral( "capture" );
}

bool KdenliveSettings::defaultEnableshuttleValue_helper()
{

  return false;
}

int KdenliveSettings::defaultBezier_gridlinesValue_helper()
{

  return 3;
}

bool KdenliveSettings::defaultBezier_showpixmapValue_helper()
{

  return false;
}

bool KdenliveSettings::defaultBezier_showallhandlesValue_helper()
{

  return true;
}

int KdenliveSettings::defaultDragvalue_modeValue_helper()
{

  return 0;
}

bool KdenliveSettings::defaultDragvalue_directupdateValue_helper()
{

  return true;
}

int KdenliveSettings::defaultProperties_panel_pageValue_helper()
{

  return 0;
}

double KdenliveSettings::defaultProject_fpsValue_helper()
{

  return 25;
}

QStringList KdenliveSettings::defaultLayoutsOrderValue_helper()
{
  QStringList defaultlayoutsOrder;
  defaultlayoutsOrder.append( QString::fromUtf8( "logging" ) );
  defaultlayoutsOrder.append( QString::fromUtf8( "editing" ) );
  defaultlayoutsOrder.append( QString::fromUtf8( "audio" ) );
  defaultlayoutsOrder.append( QString::fromUtf8( "effects" ) );
  defaultlayoutsOrder.append( QString::fromUtf8( "color" ) );

  return defaultlayoutsOrder;
}

bool KdenliveSettings::defaultShowdescriptioncolumnValue_helper()
{

  return true;
}

bool KdenliveSettings::defaultShowratingcolumnValue_helper()
{

  return false;
}

bool KdenliveSettings::defaultShowdatecolumnValue_helper()
{

  return false;
}

bool KdenliveSettings::defaultFrametimecodeValue_helper()
{

  return false;
}

bool KdenliveSettings::defaultRectimecodeValue_helper()
{

  return false;
}

bool KdenliveSettings::defaultSnaptopointsValue_helper()
{

  return true;
}

bool KdenliveSettings::defaultShowClipOverlaysValue_helper()
{

  return true;
}

bool KdenliveSettings::defaultRippleResizeValue_helper()
{

  return false;
}

bool KdenliveSettings::defaultLockedGuidesValue_helper()
{

  return true;
}

bool KdenliveSettings::defaultTagsintimelineValue_helper()
{

  return true;
}

bool KdenliveSettings::defaultTimelinemousezoomonplayheadValue_helper()
{

  return false;
}

bool KdenliveSettings::defaultTransitionfollowcursorValue_helper()
{

  return true;
}

bool KdenliveSettings::defaultKeyframeseekValue_helper()
{

  return true;
}

bool KdenliveSettings::defaultShoweffectinfoValue_helper()
{

  return false;
}

bool KdenliveSettings::defaultApplyEffectParamsToGroupValue_helper()
{

  return false;
}

bool KdenliveSettings::defaultApplyEffectParamsToGroupWithSameValueValue_helper()
{

  return true;
}

QString KdenliveSettings::defaultRenderProfileValue_helper()
{

  return QStringLiteral( "MP4-H264/AAC" );
}

bool KdenliveSettings::defaultKeepRenderLogFilesValue_helper()
{

  return false;
}

int KdenliveSettings::defaultDisplayClipMonitorInfoValue_helper()
{

  return 0x55;
}

bool KdenliveSettings::defaultShowClipMonitorSafeZoneValue_helper()
{

  return false;
}

bool KdenliveSettings::defaultShowProjectMonitorSafeZoneValue_helper()
{

  return false;
}

int KdenliveSettings::defaultDisplayProjectMonitorInfoValue_helper()
{

  return 0x05;
}

int KdenliveSettings::defaultPreviewScalingValue_helper()
{

  return 1;
}

bool KdenliveSettings::defaultAutoKeyframeValue_helper()
{

  return true;
}

int KdenliveSettings::defaultLimitAutoKeyframesValue_helper()
{

  return 0;
}

int KdenliveSettings::defaultLimitAutoKeyframesIntervalValue_helper()
{

  return 10;
}

int KdenliveSettings::defaultMaskOpacityValue_helper()
{

  return 100;
}

bool KdenliveSettings::defaultMaskInvertedValue_helper()
{

  return false;
}

int KdenliveSettings::defaultClipMonitorOverlayGuidesValue_helper()
{

  return 0;
}

int KdenliveSettings::defaultProjectMonitorOverlayGuidesValue_helper()
{

  return 0;
}

bool KdenliveSettings::defaultAlwaysShowMonitorAudioValue_helper()
{

  return false;
}

bool KdenliveSettings::defaultDisplayAudioOverlayValue_helper()
{

  return false;
}

int KdenliveSettings::defaultMonitoraudioValue_helper()
{

  return 0x07;
}

bool KdenliveSettings::defaultShowOnMonitorSceneValue_helper()
{

  return true;
}

bool KdenliveSettings::defaultMixerCollapseValue_helper()
{

  return false;
}

bool KdenliveSettings::defaultShowslideshowthumbsValue_helper()
{

  return false;
}

bool KdenliveSettings::defaultShowtitlebarsValue_helper()
{

  return true;
}

QColor KdenliveSettings::defaultColorclipcolorValue_helper()
{

  return QColor( "#000000" );
}

bool KdenliveSettings::defaultShowSubtitlesValue_helper()
{

  return false;
}

double KdenliveSettings::defaultSubtitleEditFontSizeValue_helper()
{

  return 0;
}

QColor KdenliveSettings::defaultThumbColor1Value_helper()
{

  return QColor( "#2ac1a0" );
}

QColor KdenliveSettings::defaultThumbColor2Value_helper()
{

  return QColor( "#2ed172" );
}

QColor KdenliveSettings::defaultOverlayColorValue_helper()
{

  return QColor( "#00ffff" );
}

QColor KdenliveSettings::defaultSafeColorValue_helper()
{

  return QColor( "#ffcc00" );
}

int KdenliveSettings::defaultDefaultrescalewidthValue_helper()
{

  return 320;
}

int KdenliveSettings::defaultDefaultrescaleheightValue_helper()
{

  return 240;
}

bool KdenliveSettings::defaultSlideshowbymimeValue_helper()
{

  return true;
}

bool KdenliveSettings::defaultMonitorscene_directupdateValue_helper()
{

  return false;
}

bool KdenliveSettings::defaultAnalyse_stopmotionValue_helper()
{

  return false;
}

bool KdenliveSettings::defaultEnableaudiospectrumValue_helper()
{

  return true;
}

bool KdenliveSettings::defaultShowstopmotionthumbsValue_helper()
{

  return true;
}

int KdenliveSettings::defaultCaptureintervalValue_helper()
{

  return 5;
}

int KdenliveSettings::defaultSm_notifytimeValue_helper()
{

  return 3;
}

bool KdenliveSettings::defaultSm_prenotifyValue_helper()
{

  return false;
}

bool KdenliveSettings::defaultSm_loopValue_helper()
{

  return false;
}

bool KdenliveSettings::defaultSm_playsoundValue_helper()
{

  return false;
}

int KdenliveSettings::defaultSm_framesplaybackValue_helper()
{

  return 10;
}

int KdenliveSettings::defaultStopmotioneffectValue_helper()
{

  return 0;
}

bool KdenliveSettings::defaultOnmonitoreffects_cornersshowlinesValue_helper()
{

  return false;
}

bool KdenliveSettings::defaultOnmonitoreffects_geometryshowpreviousValue_helper()
{

  return false;
}

bool KdenliveSettings::defaultOnmonitoreffects_geometryshowpathValue_helper()
{

  return true;
}

bool KdenliveSettings::defaultOnmonitoreffects_cornersshowcontrolsValue_helper()
{

  return false;
}

bool KdenliveSettings::defaultProjectloading_avformatnovalidateValue_helper()
{

  return false;
}

bool KdenliveSettings::defaultMonitor_audioValue_helper()
{

  return true;
}

bool KdenliveSettings::defaultEnable_recording_previewValue_helper()
{

  return true;
}

bool KdenliveSettings::defaultAdd_new_clipValue_helper()
{

  return true;
}

bool KdenliveSettings::defaultAdd_new_clip_to_folderValue_helper()
{

  return true;
}

int KdenliveSettings::defaultDefault_marker_typeValue_helper()
{

  return 0;
}

QString KdenliveSettings::defaultMltdeinterlacerValue_helper()
{

  return QStringLiteral( "onefield" );
}

QString KdenliveSettings::defaultMltinterpolationValue_helper()
{

  return QStringLiteral( "nearest" );
}

QStringList KdenliveSettings::defaultFavorite_effectsValue_helper()
{
  QStringList defaultfavorite_effects;
  defaultfavorite_effects.append( QString::fromUtf8( "volume" ) );
  defaultfavorite_effects.append( QString::fromUtf8( "lift_gamma_gain" ) );
  defaultfavorite_effects.append( QString::fromUtf8( "qtblend" ) );

  return defaultfavorite_effects;
}

QStringList KdenliveSettings::defaultFavorite_transitionsValue_helper()
{
  QStringList defaultfavorite_transitions;
  defaultfavorite_transitions.append( QString::fromUtf8( "wipe" ) );
  defaultfavorite_transitions.append( QString::fromUtf8( "qtblend" ) );

  return defaultfavorite_transitions;
}

int KdenliveSettings::defaultSelected_effecttabValue_helper()
{

  return 0;
}

bool KdenliveSettings::defaultEffectViewAsIconValue_helper()
{

  return false;
}

bool KdenliveSettings::defaultTransitionViewAsIconValue_helper()
{

  return false;
}

bool KdenliveSettings::defaultForce_breezeValue_helper()
{

  return false;
}

bool KdenliveSettings::defaultUse_dark_breezeValue_helper()
{

  return false;
}

bool KdenliveSettings::defaultShowWelcomeValue_helper()
{

  return true;
}

int KdenliveSettings::defaultLastSeenVersionMajorValue_helper()
{

  return 0;
}

int KdenliveSettings::defaultLastSeenVersionMinorValue_helper()
{

  return 0;
}

int KdenliveSettings::defaultLastSeenVersionMicroValue_helper()
{

  return 0;
}

bool KdenliveSettings::defaultLock_ratioValue_helper()
{

  return true;
}

bool KdenliveSettings::defaultTitlerShowGuidesValue_helper()
{

  return false;
}

int KdenliveSettings::defaultTitlerVersionValue_helper()
{

  return 0;
}

int KdenliveSettings::defaultTitlerHGuidesValue_helper()
{

  return 2;
}

int KdenliveSettings::defaultTitlerVGuidesValue_helper()
{

  return 3;
}

QColor KdenliveSettings::defaultTitleGuideColorValue_helper()
{

  return QColor( "#ff0000" );
}

int KdenliveSettings::defaultTitlerbgValue_helper()
{

  return 0;
}

bool KdenliveSettings::defaultTitlerShowbgValue_helper()
{

  return false;
}

int KdenliveSettings::defaultTitlerAlignValue_helper()
{

  return 0;
}

bool KdenliveSettings::defaultSam_offload_videoValue_helper()
{

  return false;
}

bool KdenliveSettings::defaultSam_system_pythonValue_helper()
{

  return false;
}

int KdenliveSettings::defaultMaskBorderWidthValue_helper()
{

  return 0;
}

QColor KdenliveSettings::defaultMaskBorderColorValue_helper()
{

  return QColor( "#64FF6464" );
}

QColor KdenliveSettings::defaultMaskColorValue_helper()
{

  return QColor( "#B4FF6464" );
}

bool KdenliveSettings::defaultSpeech_system_pythonValue_helper()
{

  return false;
}

bool KdenliveSettings::defaultSpeech_zoneValue_helper()
{

  return true;
}

QString KdenliveSettings::defaultWhisperModelValue_helper()
{

  return QStringLiteral( "turbo" );
}

QStringList KdenliveSettings::defaultWhisperAvailableModelsValue_helper()
{
  QStringList defaultwhisperAvailableModels;
  defaultwhisperAvailableModels.append( QString::fromUtf8( "tiny.en=tiny.en.pt" ) );
  defaultwhisperAvailableModels.append( QString::fromUtf8( "tiny=tiny.pt" ) );
  defaultwhisperAvailableModels.append( QString::fromUtf8( "base.en=base.en.pt" ) );
  defaultwhisperAvailableModels.append( QString::fromUtf8( "base=base.pt" ) );
  defaultwhisperAvailableModels.append( QString::fromUtf8( "small.en=small.en.pt" ) );
  defaultwhisperAvailableModels.append( QString::fromUtf8( "small=small.pt" ) );
  defaultwhisperAvailableModels.append( QString::fromUtf8( "medium.en=medium.en.pt" ) );
  defaultwhisperAvailableModels.append( QString::fromUtf8( "medium=medium.pt" ) );
  defaultwhisperAvailableModels.append( QString::fromUtf8( "large-v1=large-v1.pt" ) );
  defaultwhisperAvailableModels.append( QString::fromUtf8( "large-v2=large-v2.pt" ) );
  defaultwhisperAvailableModels.append( QString::fromUtf8( "large-v3=large-v3.pt" ) );
  defaultwhisperAvailableModels.append( QString::fromUtf8( "large=large-v3.pt" ) );
  defaultwhisperAvailableModels.append( QString::fromUtf8( "large-v3-turbo=large-v3-turbo.pt" ) );
  defaultwhisperAvailableModels.append( QString::fromUtf8( "turbo=large-v3-turbo.pt" ) );

  return defaultwhisperAvailableModels;
}

bool KdenliveSettings::defaultEnableSeamlessValue_helper()
{

  return false;
}

bool KdenliveSettings::defaultSrtSeamlessTranslateValue_helper()
{

  return false;
}

int KdenliveSettings::defaultWhisperMaxCharsValue_helper()
{

  return 42;
}

int KdenliveSettings::defaultSubtitleModeValue_helper()
{

  return 2;
}

bool KdenliveSettings::defaultCutWhisperMaxCharsValue_helper()
{

  return true;
}

QString KdenliveSettings::defaultWhisperDeviceValue_helper()
{

  return QStringLiteral( "cpu" );
}

QString KdenliveSettings::defaultSamDeviceValue_helper()
{

  return QStringLiteral( "cpu" );
}

bool KdenliveSettings::defaultWhisperTranslateValue_helper()
{

  return false;
}

bool KdenliveSettings::defaultWhisperDisableFP16Value_helper()
{

  return false;
}

QString KdenliveSettings::defaultSpeechEngineValue_helper()
{

  return QStringLiteral( "whisper" );
}

int KdenliveSettings::defaultMediaIconSizeValue_helper()
{

  return 16;
}

int KdenliveSettings::defaultMediaManagerPanelWidthValue_helper()
{

  return 0;
}

bool KdenliveSettings::defaultMediaBrowserAutoPlayValue_helper()
{

  return false;
}

bool KdenliveSettings::defaultMediaBrowserWithAudioValue_helper()
{

  return true;
}

bool KdenliveSettings::defaultMediaDoubleClickImportValue_helper()
{

  return true;
}

bool KdenliveSettings::defaultMediaBrowserInlinePreviewValue_helper()
{

  return true;
}

KdenliveSettings::~KdenliveSettings()
{
  if (s_globalKdenliveSettings.exists() && !s_globalKdenliveSettings.isDestroyed()) {
    s_globalKdenliveSettings()->q = nullptr;
  }
}


void KdenliveSettings::itemChanged(quint64 signalFlag) {

  switch (signalFlag) {
  case signalTreeviewheadersChanged:
    Q_EMIT treeviewheadersChanged();
    break;
  case signalBinSortingChanged:
    Q_EMIT binSortingChanged();
    break;
  case signalBinModeChanged:
    Q_EMIT binModeChanged();
    break;
  case signalBin_zoomChanged:
    Q_EMIT bin_zoomChanged();
    break;
  case signalAddedExtensionsChanged:
    Q_EMIT addedExtensionsChanged();
    break;
  case signalHoverPreviewChanged:
    Q_EMIT hoverPreviewChanged();
    break;
  case signalBinsCountChanged:
    Q_EMIT binsCountChanged();
    break;
  case signalScenesplitthresholdChanged:
    Q_EMIT scenesplitthresholdChanged();
    break;
  case signalScenesplitmarkersChanged:
    Q_EMIT scenesplitmarkersChanged();
    break;
  case signalScenesplitrangemarkersChanged:
    Q_EMIT scenesplitrangemarkersChanged();
    break;
  case signalScenesplitsubclipsChanged:
    Q_EMIT scenesplitsubclipsChanged();
    break;
  case signalCleanCacheMonthsChanged:
    Q_EMIT cleanCacheMonthsChanged();
    break;
  case signalOpenlastprojectChanged:
    Q_EMIT openlastprojectChanged();
    break;
  case signalCrashrecoveryChanged:
    Q_EMIT crashrecoveryChanged();
    break;
  case signalAutosave_timeChanged:
    Q_EMIT autosave_timeChanged();
    break;
  case signalAutosave_opsChanged:
    Q_EMIT autosave_opsChanged();
    break;
  case signalTabpositionChanged:
    Q_EMIT tabpositionChanged();
    break;
  case signalCheckfirstprojectclipChanged:
    Q_EMIT checkfirstprojectclipChanged();
    break;
  case signalKeep_original_frame_sizeChanged:
    Q_EMIT keep_original_frame_sizeChanged();
    break;
  case signalExportframe_usingsourceresChanged:
    Q_EMIT exportframe_usingsourceresChanged();
    break;
  case signalColor_durationChanged:
    Q_EMIT color_durationChanged();
    break;
  case signalImage_durationChanged:
    Q_EMIT image_durationChanged();
    break;
  case signalSequence_durationChanged:
    Q_EMIT sequence_durationChanged();
    break;
  case signalFade_durationChanged:
    Q_EMIT fade_durationChanged();
    break;
  case signalMix_durationChanged:
    Q_EMIT mix_durationChanged();
    break;
  case signalSubtitle_durationChanged:
    Q_EMIT subtitle_durationChanged();
    break;
  case signalAutoimagesequenceChanged:
    Q_EMIT autoimagesequenceChanged();
    break;
  case signalIgnoresubdirstructureChanged:
    Q_EMIT ignoresubdirstructureChanged();
    break;
  case signalDisableimagescalingChanged:
    Q_EMIT disableimagescalingChanged();
    break;
  case signalAutomultistreamsChanged:
    Q_EMIT automultistreamsChanged();
    break;
  case signalUse_exiftoolChanged:
    Q_EMIT use_exiftoolChanged();
    break;
  case signalUse_magicLanternChanged:
    Q_EMIT use_magicLanternChanged();
    break;
  case signalTitle_durationChanged:
    Q_EMIT title_durationChanged();
    break;
  case signalTransition_durationChanged:
    Q_EMIT transition_durationChanged();
    break;
  case signalEnableAssetsIncludeListChanged:
    Q_EMIT enableAssetsIncludeListChanged();
    break;
  case signalEffectsInfoHeightChanged:
    Q_EMIT effectsInfoHeightChanged();
    break;
  case signalShowEffectsInfoChanged:
    Q_EMIT showEffectsInfoChanged();
    break;
  case signalTransitionsInfoHeightChanged:
    Q_EMIT transitionsInfoHeightChanged();
    break;
  case signalShowTransitionsInfoChanged:
    Q_EMIT showTransitionsInfoChanged();
    break;
  case signalDisable_effect_parametersChanged:
    Q_EMIT disable_effect_parametersChanged();
    break;
  case signalProfile_fps_filterChanged:
    Q_EMIT profile_fps_filterChanged();
    break;
  case signalProfile_scanning_filterChanged:
    Q_EMIT profile_scanning_filterChanged();
    break;
  case signalOpengl_backendChanged:
    Q_EMIT opengl_backendChanged();
    break;
  case signalVideotracksChanged:
    Q_EMIT videotracksChanged();
    break;
  case signalAudiotracksChanged:
    Q_EMIT audiotracksChanged();
    break;
  case signalAudio_channelsChanged:
    Q_EMIT audio_channelsChanged();
    break;
  case signalEnableproxyChanged:
    Q_EMIT enableproxyChanged();
    break;
  case signalExternalproxyChanged:
    Q_EMIT externalproxyChanged();
    break;
  case signalGenerateproxyChanged:
    Q_EMIT generateproxyChanged();
    break;
  case signalExternal_proxy_profileChanged:
    Q_EMIT external_proxy_profileChanged();
    break;
  case signalExternalProxyProfileChanged:
    Q_EMIT externalProxyProfileChanged();
    break;
  case signalGenerateimageproxyChanged:
    Q_EMIT generateimageproxyChanged();
    break;
  case signalProxyminsizeChanged:
    Q_EMIT proxyminsizeChanged();
    break;
  case signalProxyimageminsizeChanged:
    Q_EMIT proxyimageminsizeChanged();
    break;
  case signalProxyimagesizeChanged:
    Q_EMIT proxyimagesizeChanged();
    break;
  case signalProxyscaleChanged:
    Q_EMIT proxyscaleChanged();
    break;
  case signalEnforceLowerTrackCompositingChanged:
    Q_EMIT enforceLowerTrackCompositingChanged();
    break;
  case signalProxyextensionChanged:
    Q_EMIT proxyextensionChanged();
    break;
  case signalProxyparamsChanged:
    Q_EMIT proxyparamsChanged();
    break;
  case signalProxy_profileChanged:
    Q_EMIT proxy_profileChanged();
    break;
  case signalProxyalphaextensionChanged:
    Q_EMIT proxyalphaextensionChanged();
    break;
  case signalProxyalphaparamsChanged:
    Q_EMIT proxyalphaparamsChanged();
    break;
  case signalAlpha_profileChanged:
    Q_EMIT alpha_profileChanged();
    break;
  case signalTranscodeFriendlyChanged:
    Q_EMIT transcodeFriendlyChanged();
    break;
  case signalTranscodingReplaceChanged:
    Q_EMIT transcodingReplaceChanged();
    break;
  case signalPreviewextensionChanged:
    Q_EMIT previewextensionChanged();
    break;
  case signalPreview_profileChanged:
    Q_EMIT preview_profileChanged();
    break;
  case signalPreviewparamsChanged:
    Q_EMIT previewparamsChanged();
    break;
  case signalParallelrenderChanged:
    Q_EMIT parallelrenderChanged();
    break;
  case signalRenderInterpChanged:
    Q_EMIT renderInterpChanged();
    break;
  case signalRenderDeinterlacerChanged:
    Q_EMIT renderDeinterlacerChanged();
    break;
  case signalVaapiEnabledChanged:
    Q_EMIT vaapiEnabledChanged();
    break;
  case signalAmfEnabledChanged:
    Q_EMIT amfEnabledChanged();
    break;
  case signalSupportedHWCodecsChanged:
    Q_EMIT SupportedHWCodecsChanged();
    break;
  case signalNvScalingEnabledChanged:
    Q_EMIT nvScalingEnabledChanged();
    break;
  case signalHwDecodingChanged:
    Q_EMIT hwDecodingChanged();
    break;
  case signalShowRenderTextParametersChanged:
    Q_EMIT showRenderTextParametersChanged();
    break;
  case signalHeaderwidthChanged:
    Q_EMIT headerwidthChanged();
    break;
  case signalDefaultkeyframeinterpChanged:
    Q_EMIT defaultkeyframeinterpChanged();
    break;
  case signalTimelinechunksChanged:
    Q_EMIT timelinechunksChanged();
    break;
  case signalAutopreviewChanged:
    Q_EMIT autopreviewChanged();
    break;
  case signalDraginprogressChanged:
    Q_EMIT draginprogressChanged();
    break;
  case signalProxypreviewChanged:
    Q_EMIT proxypreviewChanged();
    break;
  case signalMultistreamChanged:
    Q_EMIT multistreamChanged();
    break;
  case signalMultistream_checktrackChanged:
    Q_EMIT multistream_checktrackChanged();
    break;
  case signalVideothumbnailsChanged:
    Q_EMIT videothumbnailsChanged();
    break;
  case signalAudiothumbnailsChanged:
    Q_EMIT audiothumbnailsChanged();
    break;
  case signalWaveformScalerChanged:
    Q_EMIT waveformScalerChanged();
    break;
  case signalShowmarkersChanged:
    Q_EMIT showmarkersChanged();
    break;
  case signalDisplayallchannelsChanged:
    Q_EMIT displayallchannelsChanged();
    break;
  case signalNormalizechannelsChanged:
    Q_EMIT normalizechannelsChanged();
    break;
  case signalAutotrackheightChanged:
    Q_EMIT autotrackheightChanged();
    break;
  case signalAutoscrollChanged:
    Q_EMIT autoscrollChanged();
    break;
  case signalCenteredplayheadChanged:
    Q_EMIT centeredplayheadChanged();
    break;
  case signalJumptostartChanged:
    Q_EMIT jumptostartChanged();
    break;
  case signalPauseonseekChanged:
    Q_EMIT pauseonseekChanged();
    break;
  case signalSeekonaddeffectChanged:
    Q_EMIT seekonaddeffectChanged();
    break;
  case signalEnableBuiltInEffectsChanged:
    Q_EMIT enableBuiltInEffectsChanged();
    break;
  case signalTenbitpipelineChanged:
    Q_EMIT tenbitpipelineChanged();
    break;
  case signalEffectsFilterChanged:
    Q_EMIT effectsFilterChanged();
    break;
  case signalTransitionsFilterChanged:
    Q_EMIT transitionsFilterChanged();
    break;
  case signalScrollverticallyChanged:
    Q_EMIT scrollverticallyChanged();
    break;
  case signalTrackheightChanged:
    Q_EMIT trackheightChanged();
    break;
  case signalAudiotracksbelowChanged:
    Q_EMIT audiotracksbelowChanged();
    break;
  case signalRaisepropsclipsChanged:
    Q_EMIT raisepropsclipsChanged();
    break;
  case signalRaisepropscompositionsChanged:
    Q_EMIT raisepropscompositionsChanged();
    break;
  case signalRaisepropsmixesChanged:
    Q_EMIT raisepropsmixesChanged();
    break;
  case signalRaisepropstracksChanged:
    Q_EMIT raisepropstracksChanged();
    break;
  case signalUiDebugModeChanged:
    Q_EMIT uiDebugModeChanged();
    break;
  case signalGpu_accelChanged:
    Q_EMIT gpu_accelChanged();
    break;
  case signalAudio_scrubChanged:
    Q_EMIT audio_scrubChanged();
    break;
  case signalSdlAudioBackendChanged:
    Q_EMIT sdlAudioBackendChanged();
    break;
  case signalAudio_backendChanged:
    Q_EMIT audio_backendChanged();
    break;
  case signalAudiobackendChanged:
    Q_EMIT audiobackendChanged();
    break;
  case signalAudio_driverChanged:
    Q_EMIT audio_driverChanged();
    break;
  case signalAudiodevicenameChanged:
    Q_EMIT audiodevicenameChanged();
    break;
  case signalAudiodrivernameChanged:
    Q_EMIT audiodrivernameChanged();
    break;
  case signalDisablereccountdownChanged:
    Q_EMIT disablereccountdownChanged();
    break;
  case signalVideodrivernameChanged:
    Q_EMIT videodrivernameChanged();
    break;
  case signalAudio_deviceChanged:
    Q_EMIT audio_deviceChanged();
    break;
  case signalWindow_backgroundChanged:
    Q_EMIT window_backgroundChanged();
    break;
  case signalShowMonitorGridChanged:
    Q_EMIT showMonitorGridChanged();
    break;
  case signalMonitorGridHChanged:
    Q_EMIT monitorGridHChanged();
    break;
  case signalMonitorGridVChanged:
    Q_EMIT monitorGridVChanged();
    break;
  case signalMonitor_backgroundChanged:
    Q_EMIT monitor_backgroundChanged();
    break;
  case signalMonitor_progressiveChanged:
    Q_EMIT monitor_progressiveChanged();
    break;
  case signalVolumeChanged:
    Q_EMIT volumeChanged();
    break;
  case signalMonitor_dropframesChanged:
    Q_EMIT monitor_dropframesChanged();
    break;
  case signalExternal_displayChanged:
    Q_EMIT external_displayChanged();
    break;
  case signalBlackmagic_output_deviceChanged:
    Q_EMIT blackmagic_output_deviceChanged();
    break;
  case signalPlay_monitor_on_clickChanged:
    Q_EMIT play_monitor_on_clickChanged();
    break;
  case signalMirrorMonitorOnFullscreenChanged:
    Q_EMIT mirrorMonitorOnFullscreenChanged();
    break;
  case signalFullscreen_monitorChanged:
    Q_EMIT fullscreen_monitorChanged();
    break;
  case signalProject_monitor_fullscreenChanged:
    Q_EMIT project_monitor_fullscreenChanged();
    break;
  case signalClip_monitor_fullscreenChanged:
    Q_EMIT clip_monitor_fullscreenChanged();
    break;
  case signalPreferredcompositeChanged:
    Q_EMIT preferredcompositeChanged();
    break;
  case signalCompositingListChanged:
    Q_EMIT compositingListChanged();
    break;
  case signalSubtitle_razor_modeChanged:
    Q_EMIT subtitle_razor_modeChanged();
    break;
  case signalMltpathChanged:
    Q_EMIT mltpathChanged();
    break;
  case signalKdenliverendererpathChanged:
    Q_EMIT kdenliverendererpathChanged();
    break;
  case signalMeltpathChanged:
    Q_EMIT meltpathChanged();
    break;
  case signalFfmpegpathChanged:
    Q_EMIT ffmpegpathChanged();
    break;
  case signalFfplaypathChanged:
    Q_EMIT ffplaypathChanged();
    break;
  case signalFfprobepathChanged:
    Q_EMIT ffprobepathChanged();
    break;
  case signalProcessingthreadsChanged:
    Q_EMIT processingthreadsChanged();
    break;
  case signalProxythreadsChanged:
    Q_EMIT proxythreadsChanged();
    break;
  case signalEncodethreadsChanged:
    Q_EMIT encodethreadsChanged();
    break;
  case signalCurrenttmpfolderChanged:
    Q_EMIT currenttmpfolderChanged();
    break;
  case signalMaxcachesizeChanged:
    Q_EMIT maxcachesizeChanged();
    break;
  case signalCheckForUpdateChanged:
    Q_EMIT checkForUpdateChanged();
    break;
  case signalUsePowerManagementChanged:
    Q_EMIT usePowerManagementChanged();
    break;
  case signalLastCacheCheckChanged:
    Q_EMIT lastCacheCheckChanged();
    break;
  case signalDefaultprojectfolderChanged:
    Q_EMIT defaultprojectfolderChanged();
    break;
  case signalCustomprojectfolderChanged:
    Q_EMIT customprojectfolderChanged();
    break;
  case signalSameprojectfolderChanged:
    Q_EMIT sameprojectfolderChanged();
    break;
  case signalCapturetoprojectfolderChanged:
    Q_EMIT capturetoprojectfolderChanged();
    break;
  case signalCapturefolderChanged:
    Q_EMIT capturefolderChanged();
    break;
  case signalCaptureprojectsubfolderChanged:
    Q_EMIT captureprojectsubfolderChanged();
    break;
  case signalLibrarytodefaultfolderChanged:
    Q_EMIT librarytodefaultfolderChanged();
    break;
  case signalVideotodefaultfolderChanged:
    Q_EMIT videotodefaultfolderChanged();
    break;
  case signalLibraryfolderChanged:
    Q_EMIT libraryfolderChanged();
    break;
  case signalVideofolderChanged:
    Q_EMIT videofolderChanged();
    break;
  case signalDefaultimageappChanged:
    Q_EMIT defaultimageappChanged();
    break;
  case signalDefaultaudioappChanged:
    Q_EMIT defaultaudioappChanged();
    break;
  case signalGlaxnimatePathChanged:
    Q_EMIT glaxnimatePathChanged();
    break;
  case signalDefaultvideoappChanged:
    Q_EMIT defaultvideoappChanged();
    break;
  case signalNice_tasksChanged:
    Q_EMIT nice_tasksChanged();
    break;
  case signalExportGuidesFormatChanged:
    Q_EMIT exportGuidesFormatChanged();
    break;
  case signalMultipleguidesintervalChanged:
    Q_EMIT multipleguidesintervalChanged();
    break;
  case signalGuidesShowThumbsChanged:
    Q_EMIT guidesShowThumbsChanged();
    break;
  case signalGuidesSelectZoneChanged:
    Q_EMIT guidesSelectZoneChanged();
    break;
  case signalDefaultaudiocaptureChanged:
    Q_EMIT defaultaudiocaptureChanged();
    break;
  case signalAudiocapturevolumeChanged:
    Q_EMIT audiocapturevolumeChanged();
    break;
  case signalAudiocapturechannelsChanged:
    Q_EMIT audiocapturechannelsChanged();
    break;
  case signalAudiocapturesamplerateChanged:
    Q_EMIT audiocapturesamplerateChanged();
    break;
  case signalAudiocapturesampleformatChanged:
    Q_EMIT audiocapturesampleformatChanged();
    break;
  case signalDefaultcaptureChanged:
    Q_EMIT defaultcaptureChanged();
    break;
  case signalAlsachannelsChanged:
    Q_EMIT alsachannelsChanged();
    break;
  case signalGrab_profileChanged:
    Q_EMIT grab_profileChanged();
    break;
  case signalGrab_parametersChanged:
    Q_EMIT grab_parametersChanged();
    break;
  case signalGrab_extensionChanged:
    Q_EMIT grab_extensionChanged();
    break;
  case signalGrab_capture_typeChanged:
    Q_EMIT grab_capture_typeChanged();
    break;
  case signalGrab_follow_mouseChanged:
    Q_EMIT grab_follow_mouseChanged();
    break;
  case signalGrab_offsetxChanged:
    Q_EMIT grab_offsetxChanged();
    break;
  case signalGrab_offsetyChanged:
    Q_EMIT grab_offsetyChanged();
    break;
  case signalGrab_widthChanged:
    Q_EMIT grab_widthChanged();
    break;
  case signalGrab_heightChanged:
    Q_EMIT grab_heightChanged();
    break;
  case signalGrab_fpsChanged:
    Q_EMIT grab_fpsChanged();
    break;
  case signalGrab_hide_frameChanged:
    Q_EMIT grab_hide_frameChanged();
    break;
  case signalGrab_hide_mouseChanged:
    Q_EMIT grab_hide_mouseChanged();
    break;
  case signalDecklink_device_foundChanged:
    Q_EMIT decklink_device_foundChanged();
    break;
  case signalDecklink_capturedeviceChanged:
    Q_EMIT decklink_capturedeviceChanged();
    break;
  case signalDecklink_profileChanged:
    Q_EMIT decklink_profileChanged();
    break;
  case signalDecklink_filenameChanged:
    Q_EMIT decklink_filenameChanged();
    break;
  case signalDecklink_parametersChanged:
    Q_EMIT decklink_parametersChanged();
    break;
  case signalDecklink_extensionChanged:
    Q_EMIT decklink_extensionChanged();
    break;
  case signalEnableshuttleChanged:
    Q_EMIT enableshuttleChanged();
    break;
  case signalShuttledeviceChanged:
    Q_EMIT shuttledeviceChanged();
    break;
  case signalShuttledevicenamesChanged:
    Q_EMIT shuttledevicenamesChanged();
    break;
  case signalShuttledevicepathsChanged:
    Q_EMIT shuttledevicepathsChanged();
    break;
  case signalShuttlebuttonsChanged:
    Q_EMIT shuttlebuttonsChanged();
    break;
  case signalBezier_gridlinesChanged:
    Q_EMIT bezier_gridlinesChanged();
    break;
  case signalBezier_showpixmapChanged:
    Q_EMIT bezier_showpixmapChanged();
    break;
  case signalBezier_showallhandlesChanged:
    Q_EMIT bezier_showallhandlesChanged();
    break;
  case signalDragvalue_modeChanged:
    Q_EMIT dragvalue_modeChanged();
    break;
  case signalDragvalue_directupdateChanged:
    Q_EMIT dragvalue_directupdateChanged();
    break;
  case signalRecentProfilesChanged:
    Q_EMIT recentProfilesChanged();
    break;
  case signalRecentProfileNamesChanged:
    Q_EMIT recentProfileNamesChanged();
    break;
  case signalProperties_panel_pageChanged:
    Q_EMIT properties_panel_pageChanged();
    break;
  case signalProject_fpsChanged:
    Q_EMIT project_fpsChanged();
    break;
  case signalDefault_profileChanged:
    Q_EMIT default_profileChanged();
    break;
  case signalKdockLayoutChanged:
    Q_EMIT kdockLayoutChanged();
    break;
  case signalLayoutsOrderChanged:
    Q_EMIT layoutsOrderChanged();
    break;
  case signalShowdescriptioncolumnChanged:
    Q_EMIT showdescriptioncolumnChanged();
    break;
  case signalShowratingcolumnChanged:
    Q_EMIT showratingcolumnChanged();
    break;
  case signalShowdatecolumnChanged:
    Q_EMIT showdatecolumnChanged();
    break;
  case signalFrametimecodeChanged:
    Q_EMIT frametimecodeChanged();
    break;
  case signalRectimecodeChanged:
    Q_EMIT rectimecodeChanged();
    break;
  case signalSnaptopointsChanged:
    Q_EMIT snaptopointsChanged();
    break;
  case signalShowClipOverlaysChanged:
    Q_EMIT showClipOverlaysChanged();
    break;
  case signalRippleResizeChanged:
    Q_EMIT rippleResizeChanged();
    break;
  case signalLockedGuidesChanged:
    Q_EMIT lockedGuidesChanged();
    break;
  case signalGuidesCategoriesChanged:
    Q_EMIT guidesCategoriesChanged();
    break;
  case signalTagsintimelineChanged:
    Q_EMIT tagsintimelineChanged();
    break;
  case signalTimelinemousezoomonplayheadChanged:
    Q_EMIT timelinemousezoomonplayheadChanged();
    break;
  case signalTransitionfollowcursorChanged:
    Q_EMIT transitionfollowcursorChanged();
    break;
  case signalKeyframeseekChanged:
    Q_EMIT keyframeseekChanged();
    break;
  case signalShoweffectinfoChanged:
    Q_EMIT showeffectinfoChanged();
    break;
  case signalApplyEffectParamsToGroupChanged:
    Q_EMIT applyEffectParamsToGroupChanged();
    break;
  case signalApplyEffectParamsToGroupWithSameValueChanged:
    Q_EMIT applyEffectParamsToGroupWithSameValueChanged();
    break;
  case signalRenderProfileChanged:
    Q_EMIT renderProfileChanged();
    break;
  case signalKeepRenderLogFilesChanged:
    Q_EMIT keepRenderLogFilesChanged();
    break;
  case signalValidated_lutsChanged:
    Q_EMIT validated_lutsChanged();
    break;
  case signalDisplayClipMonitorInfoChanged:
    Q_EMIT displayClipMonitorInfoChanged();
    break;
  case signalShowClipMonitorSafeZoneChanged:
    Q_EMIT showClipMonitorSafeZoneChanged();
    break;
  case signalShowProjectMonitorSafeZoneChanged:
    Q_EMIT showProjectMonitorSafeZoneChanged();
    break;
  case signalDisplayProjectMonitorInfoChanged:
    Q_EMIT displayProjectMonitorInfoChanged();
    break;
  case signalPreviewScalingChanged:
    Q_EMIT previewScalingChanged();
    break;
  case signalAutoKeyframeChanged:
    Q_EMIT autoKeyframeChanged();
    break;
  case signalLimitAutoKeyframesChanged:
    Q_EMIT limitAutoKeyframesChanged();
    break;
  case signalLimitAutoKeyframesIntervalChanged:
    Q_EMIT limitAutoKeyframesIntervalChanged();
    break;
  case signalMaskOpacityChanged:
    Q_EMIT maskOpacityChanged();
    break;
  case signalMaskInvertedChanged:
    Q_EMIT maskInvertedChanged();
    break;
  case signalClipMonitorOverlayGuidesChanged:
    Q_EMIT clipMonitorOverlayGuidesChanged();
    break;
  case signalProjectMonitorOverlayGuidesChanged:
    Q_EMIT projectMonitorOverlayGuidesChanged();
    break;
  case signalAlwaysShowMonitorAudioChanged:
    Q_EMIT alwaysShowMonitorAudioChanged();
    break;
  case signalDisplayAudioOverlayChanged:
    Q_EMIT displayAudioOverlayChanged();
    break;
  case signalMonitoraudioChanged:
    Q_EMIT monitoraudioChanged();
    break;
  case signalShowOnMonitorSceneChanged:
    Q_EMIT showOnMonitorSceneChanged();
    break;
  case signalAutoaudiodrivernameChanged:
    Q_EMIT autoaudiodrivernameChanged();
    break;
  case signalMixerCollapseChanged:
    Q_EMIT mixerCollapseChanged();
    break;
  case signalConsumerslistChanged:
    Q_EMIT consumerslistChanged();
    break;
  case signalProducerslistChanged:
    Q_EMIT producerslistChanged();
    break;
  case signalWidgetstyleChanged:
    Q_EMIT widgetstyleChanged();
    break;
  case signalShowslideshowthumbsChanged:
    Q_EMIT showslideshowthumbsChanged();
    break;
  case signalShowtitlebarsChanged:
    Q_EMIT showtitlebarsChanged();
    break;
  case signalColorclipcolorChanged:
    Q_EMIT colorclipcolorChanged();
    break;
  case signalShowSubtitlesChanged:
    Q_EMIT showSubtitlesChanged();
    break;
  case signalSubtitleEditFontSizeChanged:
    Q_EMIT subtitleEditFontSizeChanged();
    break;
  case signalThumbColor1Changed:
    Q_EMIT thumbColor1Changed();
    break;
  case signalThumbColor2Changed:
    Q_EMIT thumbColor2Changed();
    break;
  case signalOverlayColorChanged:
    Q_EMIT overlayColorChanged();
    break;
  case signalSafeColorChanged:
    Q_EMIT safeColorChanged();
    break;
  case signalDefaultrescalewidthChanged:
    Q_EMIT defaultrescalewidthChanged();
    break;
  case signalDefaultrescaleheightChanged:
    Q_EMIT defaultrescaleheightChanged();
    break;
  case signalSlideshowbymimeChanged:
    Q_EMIT slideshowbymimeChanged();
    break;
  case signalSlideshowmimeextensionChanged:
    Q_EMIT slideshowmimeextensionChanged();
    break;
  case signalMonitorscene_directupdateChanged:
    Q_EMIT monitorscene_directupdateChanged();
    break;
  case signalAnalyse_stopmotionChanged:
    Q_EMIT analyse_stopmotionChanged();
    break;
  case signalEnableaudiospectrumChanged:
    Q_EMIT enableaudiospectrumChanged();
    break;
  case signalShowstopmotionthumbsChanged:
    Q_EMIT showstopmotionthumbsChanged();
    break;
  case signalCaptureintervalChanged:
    Q_EMIT captureintervalChanged();
    break;
  case signalSm_notifytimeChanged:
    Q_EMIT sm_notifytimeChanged();
    break;
  case signalSm_prenotifyChanged:
    Q_EMIT sm_prenotifyChanged();
    break;
  case signalSm_loopChanged:
    Q_EMIT sm_loopChanged();
    break;
  case signalSm_playsoundChanged:
    Q_EMIT sm_playsoundChanged();
    break;
  case signalSm_framesplaybackChanged:
    Q_EMIT sm_framesplaybackChanged();
    break;
  case signalStopmotioneffectChanged:
    Q_EMIT stopmotioneffectChanged();
    break;
  case signalOnmonitoreffects_cornersshowlinesChanged:
    Q_EMIT onmonitoreffects_cornersshowlinesChanged();
    break;
  case signalOnmonitoreffects_geometryshowpreviousChanged:
    Q_EMIT onmonitoreffects_geometryshowpreviousChanged();
    break;
  case signalOnmonitoreffects_geometryshowpathChanged:
    Q_EMIT onmonitoreffects_geometryshowpathChanged();
    break;
  case signalOnmonitoreffects_cornersshowcontrolsChanged:
    Q_EMIT onmonitoreffects_cornersshowcontrolsChanged();
    break;
  case signalProjectloading_avformatnovalidateChanged:
    Q_EMIT projectloading_avformatnovalidateChanged();
    break;
  case signalMonitor_audioChanged:
    Q_EMIT monitor_audioChanged();
    break;
  case signalEnable_recording_previewChanged:
    Q_EMIT enable_recording_previewChanged();
    break;
  case signalAdd_new_clipChanged:
    Q_EMIT add_new_clipChanged();
    break;
  case signalAdd_new_clip_to_folderChanged:
    Q_EMIT add_new_clip_to_folderChanged();
    break;
  case signalDefault_marker_typeChanged:
    Q_EMIT default_marker_typeChanged();
    break;
  case signalMltdeinterlacerChanged:
    Q_EMIT mltdeinterlacerChanged();
    break;
  case signalMltinterpolationChanged:
    Q_EMIT mltinterpolationChanged();
    break;
  case signalFavorite_effectsChanged:
    Q_EMIT favorite_effectsChanged();
    break;
  case signalFavorite_transitionsChanged:
    Q_EMIT favorite_transitionsChanged();
    break;
  case signalSelected_effecttabChanged:
    Q_EMIT selected_effecttabChanged();
    break;
  case signalEffectViewAsIconChanged:
    Q_EMIT effectViewAsIconChanged();
    break;
  case signalTransitionViewAsIconChanged:
    Q_EMIT transitionViewAsIconChanged();
    break;
  case signalForce_breezeChanged:
    Q_EMIT force_breezeChanged();
    break;
  case signalUse_dark_breezeChanged:
    Q_EMIT use_dark_breezeChanged();
    break;
  case signalShowWelcomeChanged:
    Q_EMIT showWelcomeChanged();
    break;
  case signalLastSeenVersionMajorChanged:
    Q_EMIT lastSeenVersionMajorChanged();
    break;
  case signalLastSeenVersionMinorChanged:
    Q_EMIT lastSeenVersionMinorChanged();
    break;
  case signalLastSeenVersionMicroChanged:
    Q_EMIT lastSeenVersionMicroChanged();
    break;
  case signalLock_ratioChanged:
    Q_EMIT lock_ratioChanged();
    break;
  case signalSelected_templateChanged:
    Q_EMIT selected_templateChanged();
    break;
  case signalTitlerShowGuidesChanged:
    Q_EMIT titlerShowGuidesChanged();
    break;
  case signalTitlerVersionChanged:
    Q_EMIT titlerVersionChanged();
    break;
  case signalTitlerHGuidesChanged:
    Q_EMIT titlerHGuidesChanged();
    break;
  case signalTitlerVGuidesChanged:
    Q_EMIT titlerVGuidesChanged();
    break;
  case signalTitleGuideColorChanged:
    Q_EMIT titleGuideColorChanged();
    break;
  case signalTitlerbgChanged:
    Q_EMIT titlerbgChanged();
    break;
  case signalTitlerShowbgChanged:
    Q_EMIT titlerShowbgChanged();
    break;
  case signalTitlerAlignChanged:
    Q_EMIT titlerAlignChanged();
    break;
  case signalSamModelFileChanged:
    Q_EMIT samModelFileChanged();
    break;
  case signalSam_offload_videoChanged:
    Q_EMIT sam_offload_videoChanged();
    break;
  case signalSam_system_pythonChanged:
    Q_EMIT sam_system_pythonChanged();
    break;
  case signalSam_system_python_pathChanged:
    Q_EMIT sam_system_python_pathChanged();
    break;
  case signalMaskBorderWidthChanged:
    Q_EMIT maskBorderWidthChanged();
    break;
  case signalMaskBorderColorChanged:
    Q_EMIT maskBorderColorChanged();
    break;
  case signalMaskColorChanged:
    Q_EMIT maskColorChanged();
    break;
  case signalSpeech_system_pythonChanged:
    Q_EMIT speech_system_pythonChanged();
    break;
  case signalSpeech_system_python_pathChanged:
    Q_EMIT speech_system_python_pathChanged();
    break;
  case signalVosk_folder_pathChanged:
    Q_EMIT vosk_folder_pathChanged();
    break;
  case signalVosk_text_modelChanged:
    Q_EMIT vosk_text_modelChanged();
    break;
  case signalVosk_srt_modelChanged:
    Q_EMIT vosk_srt_modelChanged();
    break;
  case signalSpeech_zoneChanged:
    Q_EMIT speech_zoneChanged();
    break;
  case signalWhisperModelChanged:
    Q_EMIT whisperModelChanged();
    break;
  case signalWhisperInstalledModelsChanged:
    Q_EMIT whisperInstalledModelsChanged();
    break;
  case signalWhisperAvailableModelsChanged:
    Q_EMIT whisperAvailableModelsChanged();
    break;
  case signalWhisperAvailableModelsHashChanged:
    Q_EMIT whisperAvailableModelsHashChanged();
    break;
  case signalWhisperModelFolderChanged:
    Q_EMIT whisperModelFolderChanged();
    break;
  case signalWhisperLanguageChanged:
    Q_EMIT whisperLanguageChanged();
    break;
  case signalEnableSeamlessChanged:
    Q_EMIT enableSeamlessChanged();
    break;
  case signalSrtSeamlessTranslateChanged:
    Q_EMIT srtSeamlessTranslateChanged();
    break;
  case signalSeamless_inputChanged:
    Q_EMIT seamless_inputChanged();
    break;
  case signalSeamless_outputChanged:
    Q_EMIT seamless_outputChanged();
    break;
  case signalWhisperMaxCharsChanged:
    Q_EMIT whisperMaxCharsChanged();
    break;
  case signalSubtitleModeChanged:
    Q_EMIT subtitleModeChanged();
    break;
  case signalCutWhisperMaxCharsChanged:
    Q_EMIT cutWhisperMaxCharsChanged();
    break;
  case signalWhisperDeviceChanged:
    Q_EMIT whisperDeviceChanged();
    break;
  case signalSamDeviceChanged:
    Q_EMIT samDeviceChanged();
    break;
  case signalWhisperTranslateChanged:
    Q_EMIT whisperTranslateChanged();
    break;
  case signalWhisperDisableFP16Changed:
    Q_EMIT whisperDisableFP16Changed();
    break;
  case signalWhisperExtraChanged:
    Q_EMIT whisperExtraChanged();
    break;
  case signalSpeechEngineChanged:
    Q_EMIT speechEngineChanged();
    break;
  case signalMediaIconSizeChanged:
    Q_EMIT mediaIconSizeChanged();
    break;
  case signalMediaManagerPanelLayoutChanged:
    Q_EMIT mediaManagerPanelLayoutChanged();
    break;
  case signalMediaManagerPanelWidthChanged:
    Q_EMIT mediaManagerPanelWidthChanged();
    break;
  case signalMediaBrowserAutoPlayChanged:
    Q_EMIT mediaBrowserAutoPlayChanged();
    break;
  case signalMediaBrowserWithAudioChanged:
    Q_EMIT mediaBrowserWithAudioChanged();
    break;
  case signalMediaDoubleClickImportChanged:
    Q_EMIT mediaDoubleClickImportChanged();
    break;
  case signalMediaBrowserInlinePreviewChanged:
    Q_EMIT mediaBrowserInlinePreviewChanged();
    break;
  }
}
