Пример #1
0
Settings::Settings(  )
  : KConfigSkeleton( QLatin1String( "netnewstickerrc" ) )
{
  Q_ASSERT(!s_globalSettings->q);
  s_globalSettings->q = this;
  setCurrentGroup( QLatin1String( "Visual" ) );

  KConfigSkeleton::ItemFont  *itemFont;
  itemFont = new KConfigSkeleton::ItemFont( currentGroup(), QLatin1String( "Font" ), mFont, KGlobalSettings::fixedFont() );
  addItem( itemFont, QLatin1String( "Font" ) );
  KConfigSkeleton::ItemColor  *itemColor;
  itemColor = new KConfigSkeleton::ItemColor( currentGroup(), QLatin1String( "Color" ), mColor, QColor( "white" ) );
  addItem( itemColor, QLatin1String( "Color" ) );
  KConfigSkeleton::ItemBool  *itemHideReadArticles;
  itemHideReadArticles = new KConfigSkeleton::ItemBool( currentGroup(), QLatin1String( "HideReadArticles" ), mHideReadArticles, true );
  addItem( itemHideReadArticles, QLatin1String( "HideReadArticles" ) );
  KConfigSkeleton::ItemBool  *itemUIStyle;
  itemUIStyle = new KConfigSkeleton::ItemBool( currentGroup(), QLatin1String( "UIStyle" ), mUIStyle, false );
  addItem( itemUIStyle, QLatin1String( "UIStyle" ) );
  KConfigSkeleton::ItemBool  *itemScrollHorizontal;
  itemScrollHorizontal = new KConfigSkeleton::ItemBool( currentGroup(), QLatin1String( "ScrollHorizontal" ), mScrollHorizontal, true );
  addItem( itemScrollHorizontal, QLatin1String( "ScrollHorizontal" ) );
  KConfigSkeleton::ItemUInt  *itemScrollingSpeed;
  itemScrollingSpeed = new KConfigSkeleton::ItemUInt( currentGroup(), QLatin1String( "ScrollingSpeed" ), mScrollingSpeed, 25 );
  addItem( itemScrollingSpeed, QLatin1String( "ScrollingSpeed" ) );
  KConfigSkeleton::ItemDouble  *itemMessageDelay;
  itemMessageDelay = new KConfigSkeleton::ItemDouble( currentGroup(), QLatin1String( "MessageDelay" ), mMessageDelay, 4 );
  addItem( itemMessageDelay, QLatin1String( "MessageDelay" ) );
  KConfigSkeleton::ItemUInt  *itemScrollingDistance;
  itemScrollingDistance = new KConfigSkeleton::ItemUInt( currentGroup(), QLatin1String( "ScrollingDistance" ), mScrollingDistance, 1 );
  addItem( itemScrollingDistance, QLatin1String( "ScrollingDistance" ) );

  setCurrentGroup( QLatin1String( "FeedLoading" ) );

  QStringList defaultFeedUrls;
  defaultFeedUrls.append( QString::fromUtf8( "http://www.kde.org/dotkdeorg.rdf" ) );

  KConfigSkeleton::ItemStringList  *itemFeedUrls;
  itemFeedUrls = new KConfigSkeleton::ItemStringList( currentGroup(), QLatin1String( "FeedUrls" ), mFeedUrls, defaultFeedUrls );
  addItem( itemFeedUrls, QLatin1String( "FeedUrls" ) );
  QList<int> defaultFeedMaxItems;

  KConfigSkeleton::ItemIntList  *itemFeedMaxItems;
  itemFeedMaxItems = new KConfigSkeleton::ItemIntList( currentGroup(), QLatin1String( "FeedMaxItems" ), mFeedMaxItems, defaultFeedMaxItems );
  addItem( itemFeedMaxItems, QLatin1String( "FeedMaxItems" ) );
  KConfigSkeleton::ItemUInt  *itemUpdateInterval;
  itemUpdateInterval = new KConfigSkeleton::ItemUInt( currentGroup(), QLatin1String( "UpdateInterval" ), mUpdateInterval, 30 );
  addItem( itemUpdateInterval, QLatin1String( "UpdateInterval" ) );
  KConfigSkeleton::ItemUInt  *itemMaxNewsItems;
  itemMaxNewsItems = new KConfigSkeleton::ItemUInt( currentGroup(), QLatin1String( "MaxNewsItems" ), mMaxNewsItems, 10 );
  addItem( itemMaxNewsItems, QLatin1String( "MaxNewsItems" ) );

  setCurrentGroup( QLatin1String( "FilterProperties" ) );

  KConfigSkeleton::ItemStringList  *itemFilterEntries;
  itemFilterEntries = new KConfigSkeleton::ItemStringList( currentGroup(), QLatin1String( "FilterEntries" ), mFilterEntries );
  addItem( itemFilterEntries, QLatin1String( "FilterEntries" ) );
}
Пример #2
0
DBGSettings::DBGSettings(const QString& name, const QString& label, LanguageSettings* langs)
  : DebuggerSettingsInterface(name, label, langs)
{
  m_widget = 0;
  setCurrentGroup( QString::fromLatin1( m_name ) );

  KConfigSkeleton::ItemBool  *itemBreakOnLoad;
  itemBreakOnLoad = new KConfigSkeleton::ItemBool( currentGroup(), QString::fromLatin1( "BreakOnLoad" ), mBreakOnLoad, true );
  addItem( itemBreakOnLoad, QString::fromLatin1( "BreakOnLoad" ) );
  KConfigSkeleton::ItemBool  *itemSendErrors;
  itemSendErrors = new KConfigSkeleton::ItemBool( currentGroup(), QString::fromLatin1( "SendErrors" ), mSendErrors, true );
  addItem( itemSendErrors, QString::fromLatin1( "SendErrors" ) );
  KConfigSkeleton::ItemBool  *itemSendLogs;
  itemSendLogs = new KConfigSkeleton::ItemBool( currentGroup(), QString::fromLatin1( "SendLogs" ), mSendLogs, true );
  addItem( itemSendLogs, QString::fromLatin1( "SendLogs" ) );
  KConfigSkeleton::ItemBool  *itemSendOutput;
  itemSendOutput = new KConfigSkeleton::ItemBool( currentGroup(), QString::fromLatin1( "SendOutput" ), mSendOutput, true );
  addItem( itemSendOutput, QString::fromLatin1( "SendOutput" ) );
  KConfigSkeleton::ItemBool  *itemSendDetailedOutput;
  itemSendDetailedOutput = new KConfigSkeleton::ItemBool( currentGroup(), QString::fromLatin1( "SendDetailedOutput" ), mSendDetailedOutput, true );
  addItem( itemSendDetailedOutput, QString::fromLatin1( "SendDetailedOutput" ) );
  KConfigSkeleton::ItemInt  *itemListenPort;
  itemListenPort = new KConfigSkeleton::ItemInt( currentGroup(), QString::fromLatin1( "ListenPort" ), mListenPort, DBG_DEFAULT_PORT );
  addItem( itemListenPort, QString::fromLatin1( "ListenPort" ) );

  KConfigSkeleton::ItemBool  *itemEnableJIT;
  itemEnableJIT = new KConfigSkeleton::ItemBool( currentGroup(), QString::fromLatin1( "EnableJIT" ), mEnableJIT, false );
  addItem( itemEnableJIT, QString::fromLatin1( "EnableJIT" ) );

  readConfig();
}
Пример #3
0
GBSettings::GBSettings(const QString& name)
  : DebuggerSettingsInterface(), m_name(name)
{
  m_widget = 0;
  
  setCurrentGroup( QString::fromLatin1( m_name ) );

  KConfigSkeleton::ItemInt  *itemListenPort;
  itemListenPort = new KConfigSkeleton::ItemInt( currentGroup(), QString::fromLatin1( "ListenPort" ), mListenPort, GB_DEFAULT_PORT );
  addItem( itemListenPort, QString::fromLatin1( "ListenPort" ) );

  KConfigSkeleton::ItemBool  *itemEnableJIT;
  itemEnableJIT = new KConfigSkeleton::ItemBool( currentGroup(), QString::fromLatin1( "EnableJIT" ), mEnableJIT, true );
  addItem( itemEnableJIT, QString::fromLatin1( "EnableJIT" ) );

  KConfigSkeleton::ItemString  *itemStartSessionScript;
  itemStartSessionScript = new KConfigSkeleton::ItemString( currentGroup(), QString::fromLatin1( "StartSessionScript" ), mStartSessionScript, "/Gubed/ServerScripts/StartSession.php");
  addItem( itemStartSessionScript, QString::fromLatin1( "StartSessionScript" ) );

  KConfigSkeleton::ItemBool  *itemBreakOnLoad;
  itemBreakOnLoad = new KConfigSkeleton::ItemBool( currentGroup(), QString::fromLatin1( "BreakOnLoad" ), mBreakOnLoad, true);
  addItem( itemBreakOnLoad, QString::fromLatin1( "BreakOnLoad" ) );

  readConfig();
}
Пример #4
0
PHPSettings::PHPSettings(const QString& configFile)
  : LanguageSettings( QString::fromLatin1( configFile ) )
{
  AbstractDebugger* def = new DebuggerDBG(this);
  m_debuggerList.append(def);
  m_debuggerList.append(new DebuggerXD(this));
  m_debuggerList.append(new DebuggerGB(this));

  setCurrentGroup( QString::fromLatin1( "PHP" ) );

  KConfigSkeleton::ItemString  *itemDefaultDebugger;
  itemDefaultDebugger = new KConfigSkeleton::ItemString( currentGroup(), QString::fromLatin1( "DefaultDebugger" ), mDefaultDebugger, def->name() );
  addItem( itemDefaultDebugger, QString::fromLatin1( "DefaultDebugger" ) );

  KConfigSkeleton::ItemString  *itemPHPCommand;
  itemPHPCommand = new KConfigSkeleton::ItemString( currentGroup(), QString::fromLatin1( "PHPCommand" ), mPHPCommand, "php");
  addItem( itemPHPCommand, QString::fromLatin1( "PHPCommand" ) );

  KConfigSkeleton::ItemBool  *itemEnabled;
  itemEnabled = new KConfigSkeleton::ItemBool( currentGroup(), QString::fromLatin1( "Enabled" ), mEnabled, true );
  addItem(itemEnabled, QString::fromLatin1( "Enabled" ) );

  readConfig();

}
Пример #5
0
KupSettings::KupSettings(KSharedConfigPtr pConfig, QObject *pParent)
   : KConfigSkeleton(pConfig, pParent)
{
	setCurrentGroup(QLatin1String("Kup settings"));
	addItemBool(QLatin1String("Backups enabled"), mBackupsEnabled);
	addItemInt(QLatin1String("Number of backups"), mNumberOfPlans, 0);
}
Пример #6
0
XDSettings::XDSettings(const QString& name)
  : DebuggerSettingsInterface(), m_name(name)
{
  m_widget = 0;
  
  setCurrentGroup( QString::fromLatin1( m_name ) );

  KConfigSkeleton::ItemInt  *itemListenPort;
  itemListenPort = new KConfigSkeleton::ItemInt( currentGroup(), QString::fromLatin1( "ListenPort" ), mListenPort, XD_DEFAULT_PORT );
  addItem( itemListenPort, QString::fromLatin1( "ListenPort" ) );

  KConfigSkeleton::ItemBool  *itemEnableJIT;
  itemEnableJIT = new KConfigSkeleton::ItemBool( currentGroup(), QString::fromLatin1( "EnableJIT" ), mEnableJIT, true );
  addItem( itemEnableJIT, QString::fromLatin1( "EnableJIT" ) );

  
  KConfigSkeleton::ItemBool  *itemSendSuperGlobals;
  itemSendSuperGlobals = new KConfigSkeleton::ItemBool( currentGroup(), QString::fromLatin1( "SendSuperGlobals" ), mSendSuperGlobals, false);
  addItem( itemSendSuperGlobals, QString::fromLatin1( "SendSuperGlobals" ) );
  
  KConfigSkeleton::ItemBool  *itemBreakOnLoad;
  itemBreakOnLoad = new KConfigSkeleton::ItemBool( currentGroup(), QString::fromLatin1( "BreakOnLoad" ), mBreakOnLoad, false);
  addItem( itemBreakOnLoad, QString::fromLatin1( "BreakOnLoad" ) );

  readConfig();
}
Пример #7
0
void KConfigSkeletonTest::initTestCase()
{

  setCurrentGroup("MyGroup");
  addItemBool("MySetting1",mMyBool,DEFAULT_SETTING1);
  addItemColor("MySetting2",mMyColor,DEFAULT_SETTING2);

  setCurrentGroup("MyOtherGroup");
  addItemFont("MySetting3",mMyFont,DEFAULT_SETTING3);
  addItemString("MySetting4",mMyString,DEFAULT_SETTING4);

  QCOMPARE( mMyBool, DEFAULT_SETTING1 );
  QCOMPARE( mMyColor, DEFAULT_SETTING2 );
  QCOMPARE( mMyFont, DEFAULT_SETTING3 );
  QCOMPARE( mMyString, DEFAULT_SETTING4 );

}
Пример #8
0
Settings::Settings(  )
  : KConfigSkeleton()
{
  Q_ASSERT(!s_globalSettings->q);
  s_globalSettings->q = this;
  setCurrentGroup( QLatin1String( "General" ) );

  mReadOnlyItem = new KConfigSkeleton::ItemBool( currentGroup(), QLatin1String( "ReadOnly" ), mReadOnly, false );
  mReadOnlyItem->setLabel( i18n("Do not change the actual backend data.") );
  addItem( mReadOnlyItem, QLatin1String( "ReadOnly" ) );
}
Пример #9
0
Settings::Settings(  )
  : KConfigSkeleton( QLatin1String( "kdiamondrc" ) )
{
  Q_ASSERT(!s_globalSettings->q);
  s_globalSettings->q = this;
  setCurrentGroup( QLatin1String( "Preferences" ) );

  KConfigSkeleton::ItemBool  *itemUntimed;
  itemUntimed = new KConfigSkeleton::ItemBool( currentGroup(), QLatin1String( "Untimed" ), mUntimed, false );
  addItem( itemUntimed, QLatin1String( "Untimed" ) );
}
Пример #10
0
void InputMethodManager::buildDefaultGroup() {
    FCITX_D();
    std::string name = _("Default");
    auto result = d->groups_.emplace(name, InputMethodGroup(name));
    auto &group = result.first->second;
    // FIXME
    group.inputMethodList().emplace_back(InputMethodGroupItem("fcitx-keyboard-us"));
    group.setDefaultInputMethod("");
    group.setDefaultLayout("us");
    setCurrentGroup(name);
    setGroupOrder({name});
}
Пример #11
0
XineCfg::XineCfg(  )
  : KConfigSkeleton( QString::fromLatin1( "panarc" ) )
{
  mSelf = this;
  setCurrentGroup( QString::fromLatin1( "Xine-Engine" ) );

  KConfigSkeleton::ItemString  *itemOutputPlugin;
  itemOutputPlugin = new KConfigSkeleton::ItemString( currentGroup(), QString::fromLatin1( "Output Plugin" ), mOutputPlugin, QString::fromLatin1( "auto" ) );
  addItem( itemOutputPlugin, QString::fromLatin1( "OutputPlugin" ) );
  KConfigSkeleton::ItemBool  *itemCustomDevice;
  itemCustomDevice = new KConfigSkeleton::ItemBool( currentGroup(), QString::fromLatin1( "Custom Device" ), mCustomDevice, false );
  addItem( itemCustomDevice, QString::fromLatin1( "CustomDevice" ) );
}
Пример #12
0
PHPSettings::PHPSettings(  )
  : KConfigSkeleton( QString::fromLatin1( "protoeditorrc" ) )
{
  setCurrentGroup( QString::fromLatin1( "PHP" ) );

  KConfigSkeleton::ItemString  *itemDefaultDebugger;
  itemDefaultDebugger = new KConfigSkeleton::ItemString( currentGroup(), QString::fromLatin1( "DefaultDebugger" ), mDefaultDebugger );
  addItem( itemDefaultDebugger, QString::fromLatin1( "DefaultDebugger" ) );

  KConfigSkeleton::ItemString  *itemPHPCommand;
  itemPHPCommand = new KConfigSkeleton::ItemString( currentGroup(), QString::fromLatin1( "PHPCommand" ), mPHPCommand, "php %1");
  addItem( itemPHPCommand, QString::fromLatin1( "PHPCommand" ) );

  readConfig();
}
Пример #13
0
Config::Config(QObject *parent) : KCoreConfigSkeleton(KSharedConfig::openConfig(QStringLiteral(CONFIG_NAME)), parent)
{
    setCurrentGroup(QStringLiteral("preferences"));
    addItemDouble(QStringLiteral("MinTemp"), m_minTemp, 30.0);
    addItemDouble(QStringLiteral("MaxTemp"), m_maxTemp, 90.0);
    addItemString(QStringLiteral("ServiceName"), m_serviceName, QStringLiteral(STANDARD_SERVICE_NAME));
    addItemPath(QStringLiteral("ConfigUrl"), m_configUrl, QStringLiteral("file://") + STANDARD_CONFIG_FILE);
    addItemStringList(QStringLiteral("Profiles"), m_profiles, QStringList());
    addItemStringList(QStringLiteral("ProfileNames"), m_profileNames, QStringList());
    addItemInt(QStringLiteral("CurrentProfile"), m_currentProfile, 0);
    addItemBool(QStringLiteral("ShowTray"), m_showTray, false);
    addItemBool(QStringLiteral("StartMinimized"), m_startMinimized, false);

    load();
}
Пример #14
0
NxDocument::NxDocument(ApplicationCurrent *parent, UiFileItem *_fileItem) :
    QObject(parent) {
    fileItem = _fileItem;
    if(fileItem) {
        connect(fileItem, SIGNAL(askFileClose()),  SLOT(askFileClose()));
        connect(fileItem, SIGNAL(askFileOpen()),   SLOT(askFileOpen()));
        connect(fileItem, SIGNAL(askFileReload()), SLOT(askFileReload()));
        connect(fileItem, SIGNAL(askFileSave()),   SLOT(askFileSave()));
    }
    skipClose = false;
    variable = 0;
    setCurrentObject(0);
    setCurrentGroup(0);
    currentCurve = 0;
    snapshotsIndex = 0;
    isLoaded = false;
}
Пример #15
0
ExtAppSettings::ExtAppSettings(const QString& configFile)
  : KConfigSkeleton( QString::fromLatin1( configFile ) )
{
  setCurrentGroup( QString::fromLatin1( "ExternalApp" ) );

  KConfigSkeleton::ItemBool  *itemUseExternalBrowser;
  itemUseExternalBrowser = new KConfigSkeleton::ItemBool( currentGroup(), QString::fromLatin1( "UseExternalBrowser" ), mUseExternalBrowser, false );
  addItem( itemUseExternalBrowser, QString::fromLatin1( "UseExternalBrowser" ) );

  QValueList<KConfigSkeleton::ItemEnum::Choice> valuesBrowser;
  {
    KConfigSkeleton::ItemEnum::Choice choice;
    choice.name = QString::fromLatin1( "Konqueror" );
    valuesBrowser.append( choice );
  }
  {
    KConfigSkeleton::ItemEnum::Choice choice;
    choice.name = QString::fromLatin1( "Mozilla" );
    valuesBrowser.append( choice );
  }
  {
    KConfigSkeleton::ItemEnum::Choice choice;
    choice.name = QString::fromLatin1( "Firefox" );
    valuesBrowser.append( choice );
  }
  {
    KConfigSkeleton::ItemEnum::Choice choice;
    choice.name = QString::fromLatin1( "Opera" );
    valuesBrowser.append( choice );
  }

  KConfigSkeleton::ItemEnum  *itemExtApp;
  itemExtApp = new KConfigSkeleton::ItemEnum( currentGroup(), QString::fromLatin1( "Browser" ), mExternalBrowser, valuesBrowser, EnumBrowser::Konqueror );
  addItem( itemExtApp, QString::fromLatin1( "Session" ) );

  KConfigSkeleton::ItemBool  *itemUseConsole;
  itemUseConsole = new KConfigSkeleton::ItemBool( currentGroup(), QString::fromLatin1( "UseConsole" ), mUseConsole, true);
  addItem( itemUseConsole, QString::fromLatin1( "UseConsole" ) );

  KConfigSkeleton::ItemString  *itemConsole;
  itemConsole = new KConfigSkeleton::ItemString( currentGroup(), QString::fromLatin1( "Console" ), mConsole, "konsole -e");
  addItem( itemConsole, QString::fromLatin1( "Console" ) );

  readConfig();
}
Пример #16
0
void InputMethodManager::loadConfig() {
    FCITX_D();
    auto &path = StandardPath::global();
    auto file = path.open(StandardPath::Type::Config, "fcitx5/profile", O_RDONLY);
    RawConfig config;
    if (file.fd() >= 0) {
        readFromIni(config, file.fd());
    }
    InputMethodConfig imConfig;
    imConfig.load(config);

    d->groups_.clear();
    std::vector<std::string> tempOrder;
    if (imConfig.groups.value().size()) {
        auto &groupsConfig = imConfig.groups.value();
        for (auto &groupConfig : groupsConfig) {
            // group must have a name
            if (groupConfig.name.value().empty() || groupConfig.defaultLayout.value().empty()) {
                continue;
            }
            auto result = d->groups_.emplace(groupConfig.name.value(), InputMethodGroup(groupConfig.name.value()));
            tempOrder.push_back(groupConfig.name.value());
            auto &group = result.first->second;
            group.setDefaultLayout(groupConfig.defaultLayout.value());
            auto &items = groupConfig.items.value();
            for (auto &item : items) {
                group.inputMethodList().emplace_back(
                    std::move(InputMethodGroupItem(item.name.value()).setLayout(item.layout.value())));
            }
            group.setDefaultInputMethod(groupConfig.defaultInputMethod.value());
        }
    }

    if (d->groups_.size() == 0) {
        buildDefaultGroup();
    } else {
        setCurrentGroup(imConfig.currentGroup.value());
        if (imConfig.groupOrder.value().size()) {
            setGroupOrder(imConfig.groupOrder.value());
        } else {
            setGroupOrder(tempOrder);
        }
    }
}
Пример #17
0
PythonSettings::PythonSettings(  )
  : LanguageSettings( QString::fromLatin1( "protoeditorrc" ) )
{
  AbstractDebugger* def = new DebuggerPythonDBGP(this);
  m_debuggerList.append(def);

  setCurrentGroup( QString::fromLatin1( "Python" ) );

  KConfigSkeleton::ItemString  *itemPythonCommand;
  itemPythonCommand = new KConfigSkeleton::ItemString( currentGroup(), QString::fromLatin1( "PythonCommand" ), mPythonCommand, "python");
  addItem( itemPythonCommand, QString::fromLatin1( "PythonCommand" ) );

  KConfigSkeleton::ItemString  *itemDefaultDebugger;
  itemDefaultDebugger = new KConfigSkeleton::ItemString( currentGroup(), QString::fromLatin1( "DefaultDebugger" ), mDefaultDebugger, def->name());
  addItem( itemDefaultDebugger, QString::fromLatin1( "DefaultDebugger" ) );

  KConfigSkeleton::ItemBool  *itemEnabled;
  itemEnabled = new KConfigSkeleton::ItemBool( currentGroup(), QString::fromLatin1( "Enabled" ), mEnabled, true );
  addItem(itemEnabled, QString::fromLatin1( "Enabled" ) );

  readConfig();
}
Пример #18
0
Settings::Settings(  )
  : KConfigSkeleton( QLatin1String( "playbakrc" ) )
{
  Q_ASSERT(!s_globalSettings->q);
  s_globalSettings->q = this;
  setCurrentGroup( QLatin1String( "Preferences" ) );

  KConfigSkeleton::ItemColor  *itemCol_background;
  itemCol_background = new KConfigSkeleton::ItemColor( currentGroup(), QLatin1String( "col_background" ), mCol_background, QColor( "black" ) );
  addItem( itemCol_background, QLatin1String( "col_background" ) );
  KConfigSkeleton::ItemColor  *itemCol_foreground;
  itemCol_foreground = new KConfigSkeleton::ItemColor( currentGroup(), QLatin1String( "col_foreground" ), mCol_foreground, QColor( "yellow" ) );
  addItem( itemCol_foreground, QLatin1String( "col_foreground" ) );
  KConfigSkeleton::ItemInt  *itemVal_time;
  itemVal_time = new KConfigSkeleton::ItemInt( currentGroup(), QLatin1String( "val_time" ), mVal_time, 2 );
  addItem( itemVal_time, QLatin1String( "val_time" ) );
  KConfigSkeleton::ItemBool  *itemShow_tray_icon;
  itemShow_tray_icon = new KConfigSkeleton::ItemBool( currentGroup(), QLatin1String( "show_tray_icon" ), mShow_tray_icon, 1 );
  addItem( itemShow_tray_icon, QLatin1String( "show_tray_icon" ) );
  KConfigSkeleton::ItemBool  *itemShow_notifications;
  itemShow_notifications = new KConfigSkeleton::ItemBool( currentGroup(), QLatin1String( "show_notifications" ), mShow_notifications, 1 );
  addItem( itemShow_notifications, QLatin1String( "show_notifications" ) );
}
Пример #19
0
SiteSettings::SiteSettings(const QString &number)
  : KConfigSkeleton( QString::fromLatin1( "protoeditorrc" ) )
  , mParamnumber(number)
{

  setCurrentGroup( QString::fromLatin1( "Site_%1" ).arg( mParamnumber ) );

  KConfigSkeleton::ItemString  *itemName;
  itemName = new KConfigSkeleton::ItemString( currentGroup(), QString::fromLatin1( "Name" ), mName );
  addItem( itemName, QString::fromLatin1( "Name" ) );
  KConfigSkeleton::ItemString  *itemUrl;
  itemUrl = new KConfigSkeleton::ItemString( currentGroup(), QString::fromLatin1( "URL" ), mUrl );
  addItem( itemUrl, QString::fromLatin1( "URL" ) );
  
  KConfigSkeleton::ItemPath  *itemLocalBaseDir;
  itemLocalBaseDir = new KConfigSkeleton::ItemPath( currentGroup(), QString::fromLatin1( "LocalBaseDir" ), mLocalBaseDir );
  addItem( itemLocalBaseDir, QString::fromLatin1( "LocalBaseDir" ) );

  KConfigSkeleton::ItemPath  *itemRemoteBaseDir;
  itemRemoteBaseDir = new KConfigSkeleton::ItemPath( currentGroup(), QString::fromLatin1( "RemoteBaseDir" ), mRemoteBaseDir );
  addItem( itemRemoteBaseDir, QString::fromLatin1( "RemoteBaseDir" ) );

  KConfigSkeleton::ItemPath  *itemDefaultFile;
  itemDefaultFile = new KConfigSkeleton::ItemPath( currentGroup(), QString::fromLatin1( "DefaultFile" ), mDefaultFile);
  addItem( itemDefaultFile, QString::fromLatin1( "DefaultFile" ) );
  
//   KConfigSkeleton::ItemBool  *itemMatchFileInLowerCase;
//   itemMatchFileInLowerCase = new KConfigSkeleton::ItemBool( currentGroup(), QString::fromLatin1( "MatchFileInLowerCase" ), mMatchFileInLowerCase, false );
//   addItem( itemMatchFileInLowerCase, QString::fromLatin1( "MatchFileInLowerCase" ) );

  KConfigSkeleton::ItemString  *itemDebuggerClient;
  itemDebuggerClient = new KConfigSkeleton::ItemString( currentGroup(), QString::fromLatin1( "DebuggerClient" ), mDebuggerClient, "DBG" );
  addItem( itemDebuggerClient, QString::fromLatin1( "DebuggerClient" ) );

  readConfig();
}
Пример #20
0
Settings::Settings(  )
  : KConfigSkeleton()
{
  Q_ASSERT(!s_globalSettings->q);
  s_globalSettings->q = this;
  setCurrentGroup( QLatin1String( "KGameTheme" ) );

  KConfigSkeleton::ItemString  *itemTheme;
  itemTheme = new KConfigSkeleton::ItemString( currentGroup(), QLatin1String( "Theme" ), mTheme, QLatin1String( "themes/default.desktop" ) );
  addItem( itemTheme, QLatin1String( "Theme" ) );

  setCurrentGroup( QLatin1String( "Notification Messages" ) );

  KConfigSkeleton::ItemBool  *itemAskDiscard;
  itemAskDiscard = new KConfigSkeleton::ItemBool( currentGroup(), QLatin1String( "askDiscard" ), mAskDiscard, true );
  addItem( itemAskDiscard, QLatin1String( "askDiscard" ) );
  KConfigSkeleton::ItemString  *itemDontAskInternal;
  itemDontAskInternal = new KConfigSkeleton::ItemString( currentGroup(), QLatin1String( "dontAskInternal" ), mDontAskInternal, QLatin1String( "\"\"" ) );
  addItem( itemDontAskInternal, QLatin1String( "dontAskInternal" ) );

  setCurrentGroup( QLatin1String( "Preferences" ) );

  QList<KConfigSkeleton::ItemEnum::Choice2> valuesanimationSpeed;
  {
    KConfigSkeleton::ItemEnum::Choice2 choice;
    choice.name = QLatin1String("Instant");
    valuesanimationSpeed.append( choice );
  }
  {
    KConfigSkeleton::ItemEnum::Choice2 choice;
    choice.name = QLatin1String("Fast");
    valuesanimationSpeed.append( choice );
  }
  {
    KConfigSkeleton::ItemEnum::Choice2 choice;
    choice.name = QLatin1String("Normal");
    valuesanimationSpeed.append( choice );
  }
  {
    KConfigSkeleton::ItemEnum::Choice2 choice;
    choice.name = QLatin1String("Slow");
    valuesanimationSpeed.append( choice );
  }
  KConfigSkeleton::ItemEnum  *itemAnimationSpeed;
  itemAnimationSpeed = new KConfigSkeleton::ItemEnum( currentGroup(), QLatin1String( "animationSpeed" ), mAnimationSpeed, valuesanimationSpeed, EnumAnimationSpeed::Normal );
  addItem( itemAnimationSpeed, QLatin1String( "animationSpeed" ) );
  KConfigSkeleton::ItemBool  *itemAnimateBoard;
  itemAnimateBoard = new KConfigSkeleton::ItemBool( currentGroup(), QLatin1String( "animateBoard" ), mAnimateBoard, false );
  addItem( itemAnimateBoard, QLatin1String( "animateBoard" ) );
  KConfigSkeleton::ItemBool  *itemFlipBoard;
  itemFlipBoard = new KConfigSkeleton::ItemBool( currentGroup(), QLatin1String( "flipBoard" ), mFlipBoard, true );
  addItem( itemFlipBoard, QLatin1String( "flipBoard" ) );
  QList<KConfigSkeleton::ItemEnum::Choice2> valuesborderDisplayType;
  {
    KConfigSkeleton::ItemEnum::Choice2 choice;
    choice.name = QLatin1String("None");
    valuesborderDisplayType.append( choice );
  }
  {
    KConfigSkeleton::ItemEnum::Choice2 choice;
    choice.name = QLatin1String("Border");
    valuesborderDisplayType.append( choice );
  }
  {
    KConfigSkeleton::ItemEnum::Choice2 choice;
    choice.name = QLatin1String("Notation");
    valuesborderDisplayType.append( choice );
  }
  KConfigSkeleton::ItemEnum  *itemBorderDisplayType;
  itemBorderDisplayType = new KConfigSkeleton::ItemEnum( currentGroup(), QLatin1String( "borderDisplayType" ), mBorderDisplayType, valuesborderDisplayType, EnumBorderDisplayType::None );
  addItem( itemBorderDisplayType, QLatin1String( "borderDisplayType" ) );
  KConfigSkeleton::ItemBool  *itemShowDanger;
  itemShowDanger = new KConfigSkeleton::ItemBool( currentGroup(), QLatin1String( "showDanger" ), mShowDanger, true );
  addItem( itemShowDanger, QLatin1String( "showDanger" ) );
  KConfigSkeleton::ItemBool  *itemShowMarker;
  itemShowMarker = new KConfigSkeleton::ItemBool( currentGroup(), QLatin1String( "showMarker" ), mShowMarker, true );
  addItem( itemShowMarker, QLatin1String( "showMarker" ) );
  KConfigSkeleton::ItemBool  *itemShowMotion;
  itemShowMotion = new KConfigSkeleton::ItemBool( currentGroup(), QLatin1String( "showMotion" ), mShowMotion, true );
  addItem( itemShowMotion, QLatin1String( "showMotion" ) );
  KConfigSkeleton::ItemBool  *itemShowClock;
  itemShowClock = new KConfigSkeleton::ItemBool( currentGroup(), QLatin1String( "showClock" ), mShowClock, true );
  addItem( itemShowClock, QLatin1String( "showClock" ) );
  KConfigSkeleton::ItemBool  *itemShowChat;
  itemShowChat = new KConfigSkeleton::ItemBool( currentGroup(), QLatin1String( "showChat" ), mShowChat, true );
  addItem( itemShowChat, QLatin1String( "showChat" ) );
  KConfigSkeleton::ItemBool  *itemShowConsole;
  itemShowConsole = new KConfigSkeleton::ItemBool( currentGroup(), QLatin1String( "showConsole" ), mShowConsole, false );
  addItem( itemShowConsole, QLatin1String( "showConsole" ) );
  KConfigSkeleton::ItemBool  *itemShowHistory;
  itemShowHistory = new KConfigSkeleton::ItemBool( currentGroup(), QLatin1String( "showHistory" ), mShowHistory, true );
  addItem( itemShowHistory, QLatin1String( "showHistory" ) );

  setCurrentGroup( QLatin1String( "Time Control" ) );

  KConfigSkeleton::ItemInt  *itemTimeLimit;
  itemTimeLimit = new KConfigSkeleton::ItemInt( currentGroup(), QLatin1String( "timeLimit" ), mTimeLimit, 10 );
  addItem( itemTimeLimit, QLatin1String( "timeLimit" ) );
  KConfigSkeleton::ItemInt  *itemTimeIncrement;
  itemTimeIncrement = new KConfigSkeleton::ItemInt( currentGroup(), QLatin1String( "timeIncrement" ), mTimeIncrement, 0 );
  addItem( itemTimeIncrement, QLatin1String( "timeIncrement" ) );
  KConfigSkeleton::ItemInt  *itemNumberOfMoves;
  itemNumberOfMoves = new KConfigSkeleton::ItemInt( currentGroup(), QLatin1String( "numberOfMoves" ), mNumberOfMoves, 40 );
  addItem( itemNumberOfMoves, QLatin1String( "numberOfMoves" ) );
  KConfigSkeleton::ItemBool  *itemTimeEnabled;
  itemTimeEnabled = new KConfigSkeleton::ItemBool( currentGroup(), QLatin1String( "timeEnabled" ), mTimeEnabled, false );
  addItem( itemTimeEnabled, QLatin1String( "timeEnabled" ) );

  setCurrentGroup( QLatin1String( "Protocols" ) );

  QList<KConfigSkeleton::ItemEnum::Choice2> valuesplayer1Protocol;
  {
    KConfigSkeleton::ItemEnum::Choice2 choice;
    choice.name = QLatin1String("Local");
    valuesplayer1Protocol.append( choice );
  }
  {
    KConfigSkeleton::ItemEnum::Choice2 choice;
    choice.name = QLatin1String("XBoard");
    valuesplayer1Protocol.append( choice );
  }
  KConfigSkeleton::ItemEnum  *itemPlayer1Protocol;
  itemPlayer1Protocol = new KConfigSkeleton::ItemEnum( currentGroup(), QLatin1String( "player1Protocol" ), mPlayer1Protocol, valuesplayer1Protocol, EnumPlayer1Protocol::Local );
  addItem( itemPlayer1Protocol, QLatin1String( "player1Protocol" ) );
  QList<KConfigSkeleton::ItemEnum::Choice2> valuesplayer2Protocol;
  {
    KConfigSkeleton::ItemEnum::Choice2 choice;
    choice.name = QLatin1String("Local");
    valuesplayer2Protocol.append( choice );
  }
  {
    KConfigSkeleton::ItemEnum::Choice2 choice;
    choice.name = QLatin1String("XBoard");
    valuesplayer2Protocol.append( choice );
  }
  {
    KConfigSkeleton::ItemEnum::Choice2 choice;
    choice.name = QLatin1String("Fics");
    valuesplayer2Protocol.append( choice );
  }
  KConfigSkeleton::ItemEnum  *itemPlayer2Protocol;
  itemPlayer2Protocol = new KConfigSkeleton::ItemEnum( currentGroup(), QLatin1String( "player2Protocol" ), mPlayer2Protocol, valuesplayer2Protocol, EnumPlayer2Protocol::Local );
  addItem( itemPlayer2Protocol, QLatin1String( "player2Protocol" ) );
  QList<KConfigSkeleton::ItemEnum::Choice2> valuescolor;
  {
    KConfigSkeleton::ItemEnum::Choice2 choice;
    choice.name = QLatin1String("NoColor");
    valuescolor.append( choice );
  }
  {
    KConfigSkeleton::ItemEnum::Choice2 choice;
    choice.name = QLatin1String("White");
    valuescolor.append( choice );
  }
  {
    KConfigSkeleton::ItemEnum::Choice2 choice;
    choice.name = QLatin1String("Black");
    valuescolor.append( choice );
  }
  KConfigSkeleton::ItemEnum  *itemColor;
  itemColor = new KConfigSkeleton::ItemEnum( currentGroup(), QLatin1String( "color" ), mColor, valuescolor, EnumColor::NoColor );
  addItem( itemColor, QLatin1String( "color" ) );
  QStringList defaultprograms;
  defaultprograms.append( QString::fromUtf8( "gnuchess" ) );
  defaultprograms.append( QString::fromUtf8( "crafty" ) );

  KConfigSkeleton::ItemStringList  *itemPrograms;
  itemPrograms = new KConfigSkeleton::ItemStringList( currentGroup(), QLatin1String( "programs" ), mPrograms, defaultprograms );
  addItem( itemPrograms, QLatin1String( "programs" ) );
  KConfigSkeleton::ItemString  *itemPlayer1Program;
  itemPlayer1Program = new KConfigSkeleton::ItemString( currentGroup(), QLatin1String( "player1Program" ), mPlayer1Program, QLatin1String( "gnuchess" ) );
  addItem( itemPlayer1Program, QLatin1String( "player1Program" ) );
  KConfigSkeleton::ItemString  *itemPlayer2Program;
  itemPlayer2Program = new KConfigSkeleton::ItemString( currentGroup(), QLatin1String( "player2Program" ), mPlayer2Program, QLatin1String( "gnuchess" ) );
  addItem( itemPlayer2Program, QLatin1String( "player2Program" ) );
  KConfigSkeleton::ItemInt  *itemComputerSearchDepth;
  itemComputerSearchDepth = new KConfigSkeleton::ItemInt( currentGroup(), QLatin1String( "computerSearchDepth" ), mComputerSearchDepth, 29 );
  addItem( itemComputerSearchDepth, QLatin1String( "computerSearchDepth" ) );
  KConfigSkeleton::ItemInt  *itemComputerMemorySize;
  itemComputerMemorySize = new KConfigSkeleton::ItemInt( currentGroup(), QLatin1String( "computerMemorySize" ), mComputerMemorySize, 50 );
  addItem( itemComputerMemorySize, QLatin1String( "computerMemorySize" ) );
  QStringList defaultservers;
  defaultservers.append( QString::fromUtf8( "freechess.org" ) );

  KConfigSkeleton::ItemStringList  *itemServers;
  itemServers = new KConfigSkeleton::ItemStringList( currentGroup(), QLatin1String( "servers" ), mServers, defaultservers );
  addItem( itemServers, QLatin1String( "servers" ) );
  KConfigSkeleton::ItemString  *itemCurrentServer;
  itemCurrentServer = new KConfigSkeleton::ItemString( currentGroup(), QLatin1String( "currentServer" ), mCurrentServer, QLatin1String( "freechess.org" ) );
  addItem( itemCurrentServer, QLatin1String( "currentServer" ) );
  KConfigSkeleton::ItemString  *itemFicsUsername;
  itemFicsUsername = new KConfigSkeleton::ItemString( currentGroup(), QLatin1String( "ficsUsername" ), mFicsUsername );
  addItem( itemFicsUsername, QLatin1String( "ficsUsername" ) );
  KConfigSkeleton::ItemBool  *itemGuest;
  itemGuest = new KConfigSkeleton::ItemBool( currentGroup(), QLatin1String( "guest" ), mGuest, false );
  addItem( itemGuest, QLatin1String( "guest" ) );
  KConfigSkeleton::ItemBool  *itemAutoLogin;
  itemAutoLogin = new KConfigSkeleton::ItemBool( currentGroup(), QLatin1String( "autoLogin" ), mAutoLogin, false );
  addItem( itemAutoLogin, QLatin1String( "autoLogin" ) );
  KConfigSkeleton::ItemInt  *itemComputerDelay;
  itemComputerDelay = new KConfigSkeleton::ItemInt( currentGroup(), QLatin1String( "computerDelay" ), mComputerDelay, 500 );
  addItem( itemComputerDelay, QLatin1String( "computerDelay" ) );
  QStringList defaultengineConfigurations;
  defaultengineConfigurations.append( QString::fromUtf8( "GNU Chess:gnuchess:xboard" ) );
  defaultengineConfigurations.append( QString::fromUtf8( "Crafty:crafty:xboard" ) );
  defaultengineConfigurations.append( QString::fromUtf8( "Stockfish:stockfish:uci" ) );
  defaultengineConfigurations.append( QString::fromUtf8( "Sjeng:sjeng:xboard" ) );

  KConfigSkeleton::ItemStringList  *itemEngineConfigurations;
  itemEngineConfigurations = new KConfigSkeleton::ItemStringList( currentGroup(), QLatin1String( "engineConfigurations" ), mEngineConfigurations, defaultengineConfigurations );
  addItem( itemEngineConfigurations, QLatin1String( "engineConfigurations" ) );

  setCurrentGroup( QLatin1String( "Accessibility" ) );

  KConfigSkeleton::ItemBool  *itemSpeakOpponentsMoves;
  itemSpeakOpponentsMoves = new KConfigSkeleton::ItemBool( currentGroup(), QLatin1String( "speakOpponentsMoves" ), mSpeakOpponentsMoves, true );
  addItem( itemSpeakOpponentsMoves, QLatin1String( "speakOpponentsMoves" ) );
  KConfigSkeleton::ItemBool  *itemAllowExternalControl;
  itemAllowExternalControl = new KConfigSkeleton::ItemBool( currentGroup(), QLatin1String( "allowExternalControl" ), mAllowExternalControl, true );
  addItem( itemAllowExternalControl, QLatin1String( "allowExternalControl" ) );
}
Пример #21
0
Settings::Settings(  )
  : KConfigSkeleton( "kphotobookrc" )
{
  mSelf = this;
  setCurrentGroup( "General" );

  QValueList<KConfigSkeleton::ItemEnum::Choice> valuesGeneralViewMode;
  {
    KConfigSkeleton::ItemEnum::Choice choice;
    choice.name = "IDEAlMode";
    valuesGeneralViewMode.append( choice );
  }
  {
    KConfigSkeleton::ItemEnum::Choice choice;
    choice.name = "TabPageMode";
    valuesGeneralViewMode.append( choice );
  }
  KConfigSkeleton::ItemEnum  *itemGeneralViewMode;
  itemGeneralViewMode = new KConfigSkeleton::ItemEnum( currentGroup(), "ViewMode", mGeneralViewMode, valuesGeneralViewMode, EnumGeneralViewMode::TabPageMode );
  addItem( itemGeneralViewMode, "GeneralViewMode" );
  KConfigSkeleton::ItemBool  *itemGeneralRescanWhileStartup;
  itemGeneralRescanWhileStartup = new KConfigSkeleton::ItemBool( currentGroup(), "RescanWhileStartup", mGeneralRescanWhileStartup, true );
  addItem( itemGeneralRescanWhileStartup, "GeneralRescanWhileStartup" );

  setCurrentGroup( "TagTree" );

  KConfigSkeleton::ItemInt  *itemTagTreeToolBarIconSize;
  itemTagTreeToolBarIconSize = new KConfigSkeleton::ItemInt( currentGroup(), "ToolBarIconSize", mTagTreeToolBarIconSize, 16 );
  itemTagTreeToolBarIconSize->setMinValue(16);
  itemTagTreeToolBarIconSize->setMaxValue(32);
  addItem( itemTagTreeToolBarIconSize, "TagTreeToolBarIconSize" );
  KConfigSkeleton::ItemInt  *itemTagTreeIconSize;
  itemTagTreeIconSize = new KConfigSkeleton::ItemInt( currentGroup(), "IconSize", mTagTreeIconSize, 22 );
  itemTagTreeIconSize->setMinValue(16);
  itemTagTreeIconSize->setMaxValue(48);
  addItem( itemTagTreeIconSize, "TagTreeIconSize" );
  KConfigSkeleton::ItemFont  *itemTagTreeFont;
  itemTagTreeFont = new KConfigSkeleton::ItemFont( currentGroup(), "Font", mTagTreeFont, KGlobalSettings::generalFont() );
  addItem( itemTagTreeFont, "TagTreeFont" );
  KConfigSkeleton::ItemBool  *itemTagTreeShowIcons;
  itemTagTreeShowIcons = new KConfigSkeleton::ItemBool( currentGroup(), "ShowIcons", mTagTreeShowIcons, true );
  addItem( itemTagTreeShowIcons, "TagTreeShowIcons" );
  QValueList<KConfigSkeleton::ItemEnum::Choice> valuesTagTreeFilterOperator;
  {
    KConfigSkeleton::ItemEnum::Choice choice;
    choice.name = "And";
    valuesTagTreeFilterOperator.append( choice );
  }
  {
    KConfigSkeleton::ItemEnum::Choice choice;
    choice.name = "Or";
    valuesTagTreeFilterOperator.append( choice );
  }
  KConfigSkeleton::ItemEnum  *itemTagTreeFilterOperator;
  itemTagTreeFilterOperator = new KConfigSkeleton::ItemEnum( currentGroup(), "FilterOperator", mTagTreeFilterOperator, valuesTagTreeFilterOperator, EnumTagTreeFilterOperator::And );
  addItem( itemTagTreeFilterOperator, "TagTreeFilterOperator" );
  KConfigSkeleton::ItemBool  *itemTagTreeRememberTree;
  itemTagTreeRememberTree = new KConfigSkeleton::ItemBool( currentGroup(), "RememberTree", mTagTreeRememberTree, true );
  addItem( itemTagTreeRememberTree, "TagTreeRememberTree" );
  KConfigSkeleton::ItemBool  *itemTagTreeRememberFilter;
  itemTagTreeRememberFilter = new KConfigSkeleton::ItemBool( currentGroup(), "RememberFilter", mTagTreeRememberFilter, true );
  addItem( itemTagTreeRememberFilter, "TagTreeRememberFilter" );
  KConfigSkeleton::ItemBool  *itemTagTreeLocked;
  itemTagTreeLocked = new KConfigSkeleton::ItemBool( currentGroup(), "Locked", mTagTreeLocked, false );
  addItem( itemTagTreeLocked, "TagTreeLocked" );

  setCurrentGroup( "SourceDirTree" );

  KConfigSkeleton::ItemInt  *itemSourceDirTreeToolBarIconSize;
  itemSourceDirTreeToolBarIconSize = new KConfigSkeleton::ItemInt( currentGroup(), "ToolBarIconSize", mSourceDirTreeToolBarIconSize, 16 );
  itemSourceDirTreeToolBarIconSize->setMinValue(16);
  itemSourceDirTreeToolBarIconSize->setMaxValue(32);
  addItem( itemSourceDirTreeToolBarIconSize, "SourceDirTreeToolBarIconSize" );
  QValueList<KConfigSkeleton::ItemEnum::Choice> valuesSourceDirTreeIconSize;
  KConfigSkeleton::ItemEnum  *itemSourceDirTreeIconSize;
  itemSourceDirTreeIconSize = new KConfigSkeleton::ItemEnum( currentGroup(), "IconSize", mSourceDirTreeIconSize, valuesSourceDirTreeIconSize, 22 );
  itemSourceDirTreeIconSize->setMinValue(16);
  itemSourceDirTreeIconSize->setMaxValue(48);
  addItem( itemSourceDirTreeIconSize, "SourceDirTreeIconSize" );
  KConfigSkeleton::ItemFont  *itemSourceDirTreeFont;
  itemSourceDirTreeFont = new KConfigSkeleton::ItemFont( currentGroup(), "Font", mSourceDirTreeFont, KGlobalSettings::generalFont() );
  addItem( itemSourceDirTreeFont, "SourceDirTreeFont" );
  KConfigSkeleton::ItemBool  *itemSourceDirTreeShowIcons;
  itemSourceDirTreeShowIcons = new KConfigSkeleton::ItemBool( currentGroup(), "ShowIcons", mSourceDirTreeShowIcons, true );
  addItem( itemSourceDirTreeShowIcons, "SourceDirTreeShowIcons" );
  KConfigSkeleton::ItemBool  *itemSourceDirTreeRememberTree;
  itemSourceDirTreeRememberTree = new KConfigSkeleton::ItemBool( currentGroup(), "RememberTree", mSourceDirTreeRememberTree, true );
  addItem( itemSourceDirTreeRememberTree, "SourceDirTreeRememberTree" );
  KConfigSkeleton::ItemBool  *itemSourceDirTreeRememberFilter;
  itemSourceDirTreeRememberFilter = new KConfigSkeleton::ItemBool( currentGroup(), "RememberFilter", mSourceDirTreeRememberFilter, true );
  addItem( itemSourceDirTreeRememberFilter, "SourceDirTreeRememberFilter" );

  setCurrentGroup( "ImagePreview" );

  KConfigSkeleton::ItemInt  *itemImagePreviewSize;
  itemImagePreviewSize = new KConfigSkeleton::ItemInt( currentGroup(), "Size", mImagePreviewSize, 48 );
  itemImagePreviewSize->setMinValue(32);
  itemImagePreviewSize->setMaxValue(160);
  addItem( itemImagePreviewSize, "ImagePreviewSize" );
  KConfigSkeleton::ItemFont  *itemImagePreviewFont;
  itemImagePreviewFont = new KConfigSkeleton::ItemFont( currentGroup(), "Font", mImagePreviewFont, KGlobalSettings::generalFont() );
  addItem( itemImagePreviewFont, "ImagePreviewFont" );
  KConfigSkeleton::ItemBool  *itemImagePreviewShowName;
  itemImagePreviewShowName = new KConfigSkeleton::ItemBool( currentGroup(), "ShowName", mImagePreviewShowName, true );
  addItem( itemImagePreviewShowName, "ImagePreviewShowName" );
  KConfigSkeleton::ItemBool  *itemImagePreviewAutoRefresh;
  itemImagePreviewAutoRefresh = new KConfigSkeleton::ItemBool( currentGroup(), "AutoRefresh", mImagePreviewAutoRefresh, true );
  addItem( itemImagePreviewAutoRefresh, "ImagePreviewAutoRefresh" );
  QValueList<KConfigSkeleton::ItemEnum::Choice> valuesImagePreviewSelectionMode;
  {
    KConfigSkeleton::ItemEnum::Choice choice;
    choice.name = "Extended";
    valuesImagePreviewSelectionMode.append( choice );
  }
  {
    KConfigSkeleton::ItemEnum::Choice choice;
    choice.name = "Multi";
    valuesImagePreviewSelectionMode.append( choice );
  }
  KConfigSkeleton::ItemEnum  *itemImagePreviewSelectionMode;
  itemImagePreviewSelectionMode = new KConfigSkeleton::ItemEnum( currentGroup(), "SelectionMode", mImagePreviewSelectionMode, valuesImagePreviewSelectionMode, EnumImagePreviewSelectionMode::Extended );
  addItem( itemImagePreviewSelectionMode, "ImagePreviewSelectionMode" );

  setCurrentGroup( "FileFilter" );

  QStringList defaultFileFilterFileToHandle;
  defaultFileFilterFileToHandle.append( ".*\\.jpg" );
  defaultFileFilterFileToHandle.append( ".*\\.jpeg" );

  KConfigSkeleton::ItemStringList  *itemFileFilterFileToHandle;
  itemFileFilterFileToHandle = new KConfigSkeleton::ItemStringList( currentGroup(), "FileToHandle", mFileFilterFileToHandle, defaultFileFilterFileToHandle );
  addItem( itemFileFilterFileToHandle, "FileFilterFileToHandle" );
  QStringList defaultFileFilterSubdirsToIgnore;
  defaultFileFilterSubdirsToIgnore.append( "\\..*" );
  defaultFileFilterSubdirsToIgnore.append( "[Tt]humbs" );
  defaultFileFilterSubdirsToIgnore.append( "[Tt]humbnails" );
  defaultFileFilterSubdirsToIgnore.append( "[Tt]humbNails" );

  KConfigSkeleton::ItemStringList  *itemFileFilterSubdirsToIgnore;
  itemFileFilterSubdirsToIgnore = new KConfigSkeleton::ItemStringList( currentGroup(), "SubdirsToIgnore", mFileFilterSubdirsToIgnore, defaultFileFilterSubdirsToIgnore );
  addItem( itemFileFilterSubdirsToIgnore, "FileFilterSubdirsToIgnore" );

  setCurrentGroup( "Tools" );

  KConfigSkeleton::ItemString  *itemToolsDefaultExternalTool;
  itemToolsDefaultExternalTool = new KConfigSkeleton::ItemString( currentGroup(), "DefaultExternalTool", mToolsDefaultExternalTool, "kuickshow" );
  addItem( itemToolsDefaultExternalTool, "ToolsDefaultExternalTool" );
  QStringList defaultToolsExternalTools;
  defaultToolsExternalTools.append( "kuickshow" );

  KConfigSkeleton::ItemStringList  *itemToolsExternalTools;
  itemToolsExternalTools = new KConfigSkeleton::ItemStringList( currentGroup(), "ExternalTools", mToolsExternalTools, defaultToolsExternalTools );
  addItem( itemToolsExternalTools, "ToolsExternalTools" );

  setCurrentGroup( "FileSystem" );

  KConfigSkeleton::ItemString  *itemFileSystemLastOpenedFile;
  itemFileSystemLastOpenedFile = new KConfigSkeleton::ItemString( currentGroup(), "LastOpenedFile", mFileSystemLastOpenedFile );
  addItem( itemFileSystemLastOpenedFile, "FileSystemLastOpenedFile" );
  KConfigSkeleton::ItemString  *itemFileSystemLastAddedSourcedir;
  itemFileSystemLastAddedSourcedir = new KConfigSkeleton::ItemString( currentGroup(), "LastAddedSourcedir", mFileSystemLastAddedSourcedir );
  addItem( itemFileSystemLastAddedSourcedir, "FileSystemLastAddedSourcedir" );
  KConfigSkeleton::ItemString  *itemFileSystemLastExportedToDirectory;
  itemFileSystemLastExportedToDirectory = new KConfigSkeleton::ItemString( currentGroup(), "LastExportedToDirectory", mFileSystemLastExportedToDirectory );
  addItem( itemFileSystemLastExportedToDirectory, "FileSystemLastExportedToDirectory" );
}