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

#include "smb4ksettings.h"

#include <klocalizedstring.h>

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

class Smb4KSettingsHelper
{
  public:
    Smb4KSettingsHelper() noexcept : q(nullptr) {}
    ~Smb4KSettingsHelper() noexcept { delete q; q = nullptr; }
    Smb4KSettingsHelper(const Smb4KSettingsHelper&) = delete;
    Smb4KSettingsHelper& operator=(const Smb4KSettingsHelper&) = delete;
    Smb4KSettings *q;
};
Q_GLOBAL_STATIC(Smb4KSettingsHelper, s_globalSmb4KSettings)
Smb4KSettings *Smb4KSettings::self()
{
  if (!s_globalSmb4KSettings()->q) {
    new Smb4KSettings;
    s_globalSmb4KSettings()->q->read();
  }

  return s_globalSmb4KSettings()->q;
}

Smb4KSettings::Smb4KSettings( )
  : KConfigSkeleton( QStringLiteral( "smb4krc" ) )
{
  Q_ASSERT(!s_globalSmb4KSettings()->q);
  s_globalSmb4KSettings()->q = this;
  setCurrentGroup( QStringLiteral( "UserInterface" ) );

  QList<KConfigSkeleton::ItemEnum::Choice> valuesMainWindowTabOrientation;
  {
    KConfigSkeleton::ItemEnum::Choice choice;
    choice.name = QStringLiteral("Top");
    choice.label = i18nd("smb4k-core", "Top");
    valuesMainWindowTabOrientation.append( choice );
  }
  {
    KConfigSkeleton::ItemEnum::Choice choice;
    choice.name = QStringLiteral("Bottom");
    choice.label = i18nd("smb4k-core", "Bottom");
    valuesMainWindowTabOrientation.append( choice );
  }
  {
    KConfigSkeleton::ItemEnum::Choice choice;
    choice.name = QStringLiteral("Left");
    choice.label = i18nd("smb4k-core", "Left");
    valuesMainWindowTabOrientation.append( choice );
  }
  {
    KConfigSkeleton::ItemEnum::Choice choice;
    choice.name = QStringLiteral("Right");
    choice.label = i18nd("smb4k-core", "Right");
    valuesMainWindowTabOrientation.append( choice );
  }
  mMainWindowTabOrientationItem = new KConfigSkeleton::ItemEnum( currentGroup(), QStringLiteral( "MainWindowTabOrientation" ), mMainWindowTabOrientation, valuesMainWindowTabOrientation, EnumMainWindowTabOrientation::Bottom );
  mMainWindowTabOrientationItem->setLabel( i18nd("smb4k-core", "Tab orientation:") );
  mMainWindowTabOrientationItem->setWhatsThis( i18nd("smb4k-core", "Set the tab orientation for the tabified dock widgets.") );
  addItem( mMainWindowTabOrientationItem, QStringLiteral( "MainWindowTabOrientation" ) );
  mShowCustomBookmarkLabelItem = new KConfigSkeleton::ItemBool( currentGroup(), QStringLiteral( "ShowCustomBookmarkLabel" ), mShowCustomBookmarkLabel, true );
  mShowCustomBookmarkLabelItem->setLabel( i18nd("smb4k-core", "Show custom bookmark label if available") );
  mShowCustomBookmarkLabelItem->setWhatsThis( i18nd("smb4k-core", "Do not show the name of the bookmarked share, but the custom label that was defined in the bookmark editor.") );
  addItem( mShowCustomBookmarkLabelItem, QStringLiteral( "ShowCustomBookmarkLabel" ) );
  mStartMainWindowDockedItem = new KConfigSkeleton::ItemBool( currentGroup(), QStringLiteral( "StartMainWindowDocked" ), mStartMainWindowDocked, false );
  mStartMainWindowDockedItem->setLabel( i18nd("smb4k-core", "Start docked") );
  mStartMainWindowDockedItem->setWhatsThis( i18nd("smb4k-core", "Start the application docked to the system tray, i.e. only the system tray widget is shown and the main window is hidden. You can bring the main window up by clicking on the system tray widget or by choosing \"Restore\" from its popup menu.") );
  addItem( mStartMainWindowDockedItem, QStringLiteral( "StartMainWindowDocked" ) );
  mShowTypeItem = new KConfigSkeleton::ItemBool( currentGroup(), QStringLiteral( "ShowType" ), mShowType, true );
  mShowTypeItem->setLabel( i18nd("smb4k-core", "Show the type of the share") );
  mShowTypeItem->setWhatsThis( i18nd("smb4k-core", "The type of a share will be displayed in a separate column in the network neighborhood browser. It can either be Disk, Printer or IPC.") );
  addItem( mShowTypeItem, QStringLiteral( "ShowType" ) );
  mShowIPAddressItem = new KConfigSkeleton::ItemBool( currentGroup(), QStringLiteral( "ShowIPAddress" ), mShowIPAddress, true );
  mShowIPAddressItem->setLabel( i18nd("smb4k-core", "Show the IP address of the server") );
  mShowIPAddressItem->setWhatsThis( i18nd("smb4k-core", "The IP address of the server will be displayed in a separate column in the network neighborhood browser.") );
  addItem( mShowIPAddressItem, QStringLiteral( "ShowIPAddress" ) );
  mShowCommentItem = new KConfigSkeleton::ItemBool( currentGroup(), QStringLiteral( "ShowComment" ), mShowComment, true );
  mShowCommentItem->setLabel( i18nd("smb4k-core", "Show the comment") );
  mShowCommentItem->setWhatsThis( i18nd("smb4k-core", "The comment describing the server or share will be displayed in a separate column in the network neighborhood browser.") );
  addItem( mShowCommentItem, QStringLiteral( "ShowComment" ) );
  mShowNetworkItemToolTipItem = new KConfigSkeleton::ItemBool( currentGroup(), QStringLiteral( "ShowNetworkItemToolTip" ), mShowNetworkItemToolTip, true );
  mShowNetworkItemToolTipItem->setLabel( i18nd("smb4k-core", "Show tooltips for network items") );
  mShowNetworkItemToolTipItem->setWhatsThis( i18nd("smb4k-core", "The tooltip shows various information about the current network item.") );
  addItem( mShowNetworkItemToolTipItem, QStringLiteral( "ShowNetworkItemToolTip" ) );
  mAutoExpandNetworkItemsItem = new KConfigSkeleton::ItemBool( currentGroup(), QStringLiteral( "AutoExpandNetworkItems" ), mAutoExpandNetworkItems, true );
  mAutoExpandNetworkItemsItem->setLabel( i18nd("smb4k-core", "Automatically expand domains and hosts") );
  mAutoExpandNetworkItemsItem->setWhatsThis( i18nd("smb4k-core", "Automatically expand domain and host items when a list of associated network items (domain members or shares) is added or updated. Please note that a domain or host item will always be expanded when you execute it.") );
  addItem( mAutoExpandNetworkItemsItem, QStringLiteral( "AutoExpandNetworkItems" ) );
  mShowShareToolTipItem = new KConfigSkeleton::ItemBool( currentGroup(), QStringLiteral( "ShowShareToolTip" ), mShowShareToolTip, true );
  mShowShareToolTipItem->setLabel( i18nd("smb4k-core", "Show tooltips for mounted shares") );
  mShowShareToolTipItem->setWhatsThis( i18nd("smb4k-core", "The tooltip shows various information about the current share.") );
  addItem( mShowShareToolTipItem, QStringLiteral( "ShowShareToolTip" ) );
  QList<KConfigSkeleton::ItemEnum::Choice> valuesSharesViewMode;
  {
    KConfigSkeleton::ItemEnum::Choice choice;
    choice.name = QStringLiteral("IconView");
    choice.label = i18nd("smb4k-core", "Icon View");
    valuesSharesViewMode.append( choice );
  }
  {
    KConfigSkeleton::ItemEnum::Choice choice;
    choice.name = QStringLiteral("ListView");
    choice.label = i18nd("smb4k-core", "List View");
    valuesSharesViewMode.append( choice );
  }
  mSharesViewModeItem = new KConfigSkeleton::ItemEnum( currentGroup(), QStringLiteral( "SharesViewMode" ), mSharesViewMode, valuesSharesViewMode, EnumSharesViewMode::IconView );
  mSharesViewModeItem->setLabel( i18nd("smb4k-core", "View mode:") );
  mSharesViewModeItem->setWhatsThis( i18nd("smb4k-core", "This setting determines the view mode of the shares view. There are two modes: the icon view and the list view.") );
  addItem( mSharesViewModeItem, QStringLiteral( "SharesViewMode" ) );
  mSharesViewIconSizeIconViewItem = new KConfigSkeleton::ItemInt( currentGroup(), QStringLiteral( "SharesViewIconSizeIconView" ), mSharesViewIconSizeIconView, KIconLoader::SizeLarge );
  mSharesViewIconSizeIconViewItem->setMinValue(KIconLoader::SizeSmall);
  mSharesViewIconSizeIconViewItem->setMaxValue(KIconLoader::SizeEnormous);
  mSharesViewIconSizeIconViewItem->setLabel( i18nd("smb4k-core", "Icon size for the icon view:") );
  mSharesViewIconSizeIconViewItem->setWhatsThis( i18nd("smb4k-core", "Set the icon size for the icon view mode of the shares view.") );
  addItem( mSharesViewIconSizeIconViewItem, QStringLiteral( "SharesViewIconSizeIconView" ) );
  mSharesViewIconSizeListViewItem = new KConfigSkeleton::ItemInt( currentGroup(), QStringLiteral( "SharesViewIconSizeListView" ), mSharesViewIconSizeListView, KIconLoader::SizeSmall );
  mSharesViewIconSizeListViewItem->setMinValue(KIconLoader::SizeSmall);
  mSharesViewIconSizeListViewItem->setMaxValue(KIconLoader::SizeEnormous);
  mSharesViewIconSizeListViewItem->setLabel( i18nd("smb4k-core", "Icon size for the list view:") );
  mSharesViewIconSizeListViewItem->setWhatsThis( i18nd("smb4k-core", "Set the icon size for the list view mode of the shares view.") );
  addItem( mSharesViewIconSizeListViewItem, QStringLiteral( "SharesViewIconSizeListView" ) );
  mNetworkBrowserIconSizeItem = new KConfigSkeleton::ItemInt( currentGroup(), QStringLiteral( "NetworkBrowserIconSize" ), mNetworkBrowserIconSize, KIconLoader::SizeSmall );
  mNetworkBrowserIconSizeItem->setMinValue(KIconLoader::SizeSmall);
  mNetworkBrowserIconSizeItem->setMaxValue(KIconLoader::SizeEnormous);
  mNetworkBrowserIconSizeItem->setLabel( i18nd("smb4k-core", "Icon size:") );
  mNetworkBrowserIconSizeItem->setWhatsThis( i18nd("smb4k-core", "Set the icon size for the network neighborhood browser.") );
  addItem( mNetworkBrowserIconSizeItem, QStringLiteral( "NetworkBrowserIconSize" ) );

  setCurrentGroup( QStringLiteral( "Network" ) );

  mUseWsDiscoveryItem = new KConfigSkeleton::ItemBool( currentGroup(), QStringLiteral( "UseWsDiscovery" ), mUseWsDiscovery, true );
  mUseWsDiscoveryItem->setLabel( i18nd("smb4k-core", "Use Web Services Dynamic Discovery (WS-Discovery) for browsing") );
  mUseWsDiscoveryItem->setWhatsThis( i18nd("smb4k-core", "The Web Services Dynamic Discovery (WS-Discovery) is used to browse the local network and discover workgroups, domains and hosts. This is useful, if your network neighborhood is dominated by servers with modern Windows versions. If you use this option, there should be no need to force Samba's client library to use the SMB protocol version 1.0 for searching for workgroups and domains.") );
  addItem( mUseWsDiscoveryItem, QStringLiteral( "UseWsDiscovery" ) );
  mUseDnsServiceDiscoveryItem = new KConfigSkeleton::ItemBool( currentGroup(), QStringLiteral( "UseDnsServiceDiscovery" ), mUseDnsServiceDiscovery, true );
  mUseDnsServiceDiscoveryItem->setLabel( i18nd("smb4k-core", "Use DNS Service Discovery (DNS-SD) for browsing") );
  mUseDnsServiceDiscoveryItem->setWhatsThis( i18nd("smb4k-core", "The DNS Service Discovery (DNS-SD) is used to browse the local network and discover servers that provide shared SMB resources. The discovered domains correspond to the local DNS domains (e. g. named LOCAL) and most likely not the ones defined in the network neighborhood. However, this does not influence the browsing. If you use this option, there is no need to force Samba's client library to use the SMB protocol version 1.0 for searching for workgroups and domains.") );
  addItem( mUseDnsServiceDiscoveryItem, QStringLiteral( "UseDnsServiceDiscovery" ) );
  mUseClientProtocolVersionsItem = new KConfigSkeleton::ItemBool( currentGroup(), QStringLiteral( "UseClientProtocolVersions" ), mUseClientProtocolVersions, false );
  mUseClientProtocolVersionsItem->setLabel( i18nd("smb4k-core", "Set minimal and maximal SMB protocol version") );
  mUseClientProtocolVersionsItem->setWhatsThis( i18nd("smb4k-core", "Smb4K will set the minimal and maximal SMB protocol version that is used by Samba's client library to browse the network neighborhood. This will overwrite the settings in the smb.conf file. Normally, you do not need to use this option, because the right protocol versions should be negotiated between the client and the server while establishing a connection. Please note that this setting might not be appropriate to make the discovering of workgroups and domains work while keeping undisturbed connectivity to servers. Use DNS Service Discovery (DNS-SD) or Web Services Dynamic Discovery (WS-Discovery) for domain and workgroup lookups instead.") );
  addItem( mUseClientProtocolVersionsItem, QStringLiteral( "UseClientProtocolVersions" ) );
  QList<KConfigSkeleton::ItemEnum::Choice> valuesMinimalClientProtocolVersion;
  {
    KConfigSkeleton::ItemEnum::Choice choice;
    choice.name = QStringLiteral("NT1");
    choice.label = i18nd("smb4k-core", "NT1 (Classic CIFS/SMBv1 protocol)");
    valuesMinimalClientProtocolVersion.append( choice );
  }
  {
    KConfigSkeleton::ItemEnum::Choice choice;
    choice.name = QStringLiteral("SMB2");
    choice.label = i18nd("smb4k-core", "SMB2 (Windows Vista and above)");
    valuesMinimalClientProtocolVersion.append( choice );
  }
  {
    KConfigSkeleton::ItemEnum::Choice choice;
    choice.name = QStringLiteral("SMB3");
    choice.label = i18nd("smb4k-core", "SMB3 (Windows 8 and above)");
    valuesMinimalClientProtocolVersion.append( choice );
  }
  mMinimalClientProtocolVersionItem = new KConfigSkeleton::ItemEnum( currentGroup(), QStringLiteral( "MinimalClientProtocolVersion" ), mMinimalClientProtocolVersion, valuesMinimalClientProtocolVersion, EnumMinimalClientProtocolVersion::SMB2 );
  mMinimalClientProtocolVersionItem->setLabel( i18nd("smb4k-core", "Minimal SMB protocol version:") );
  mMinimalClientProtocolVersionItem->setWhatsThis( i18nd("smb4k-core", "This setting controls the minimum protocol version that Samba's client library will attempt to use.") );
  addItem( mMinimalClientProtocolVersionItem, QStringLiteral( "MinimalClientProtocolVersion" ) );
  QList<KConfigSkeleton::ItemEnum::Choice> valuesMaximalClientProtocolVersion;
  {
    KConfigSkeleton::ItemEnum::Choice choice;
    choice.name = QStringLiteral("NT1");
    choice.label = i18nd("smb4k-core", "NT1 (Classic CIFS/SMBv1 protocol)");
    valuesMaximalClientProtocolVersion.append( choice );
  }
  {
    KConfigSkeleton::ItemEnum::Choice choice;
    choice.name = QStringLiteral("SMB2");
    choice.label = i18nd("smb4k-core", "SMB2 (Windows Vista and above)");
    valuesMaximalClientProtocolVersion.append( choice );
  }
  {
    KConfigSkeleton::ItemEnum::Choice choice;
    choice.name = QStringLiteral("SMB3");
    choice.label = i18nd("smb4k-core", "SMB3 (Windows 8 and above)");
    valuesMaximalClientProtocolVersion.append( choice );
  }
  mMaximalClientProtocolVersionItem = new KConfigSkeleton::ItemEnum( currentGroup(), QStringLiteral( "MaximalClientProtocolVersion" ), mMaximalClientProtocolVersion, valuesMaximalClientProtocolVersion, EnumMaximalClientProtocolVersion::SMB3 );
  mMaximalClientProtocolVersionItem->setLabel( i18nd("smb4k-core", "Maximal SMB protocol version:") );
  mMaximalClientProtocolVersionItem->setWhatsThis( i18nd("smb4k-core", "This setting controls the maximum protocol version that Samba's client library will attempt to use.") );
  addItem( mMaximalClientProtocolVersionItem, QStringLiteral( "MaximalClientProtocolVersion" ) );
  mUseRemoteSmbPortItem = new KConfigSkeleton::ItemBool( currentGroup(), QStringLiteral( "UseRemoteSmbPort" ), mUseRemoteSmbPort, false );
  mUseRemoteSmbPortItem->setLabel( i18nd("smb4k-core", "Set the SMB port to:") );
  mUseRemoteSmbPortItem->setWhatsThis( i18nd("smb4k-core", "This is the port that is used for connecting to remote servers. The default value is 139 (NetBIOS). Under FreeBSD, this setting is also used for mounting.") );
  addItem( mUseRemoteSmbPortItem, QStringLiteral( "UseRemoteSmbPort" ) );
  mRemoteSmbPortItem = new KConfigSkeleton::ItemInt( currentGroup(), QStringLiteral( "RemoteSmbPort" ), mRemoteSmbPort, 139 );
  mRemoteSmbPortItem->setMinValue(1);
  mRemoteSmbPortItem->setMaxValue(65535);
  mRemoteSmbPortItem->setLabel( i18nd("smb4k-core", "RemoteSmbPort") );
  mRemoteSmbPortItem->setWhatsThis( i18nd("smb4k-core", "This is the port that is used for connecting to remote servers. The default value is 139 (NetBIOS). Under FreeBSD, this setting is also used for mounting.") );
  addItem( mRemoteSmbPortItem, QStringLiteral( "RemoteSmbPort" ) );
  mLargeNetworkNeighborhoodItem = new KConfigSkeleton::ItemBool( currentGroup(), QStringLiteral( "LargeNetworkNeighborhood" ), mLargeNetworkNeighborhood, false );
  mLargeNetworkNeighborhoodItem->setLabel( i18nd("smb4k-core", "This computer is on a large network neighborhood") );
  mLargeNetworkNeighborhoodItem->setWhatsThis( i18nd("smb4k-core", "In case your computer is on a large network neighborhood, discovering all workgroups, hosts and shares might take a long time, since in the default configuration all local master browsers are queried. Enabling this setting limits the number of used local master browsers to three. This can reduced the time consumption on large network neighborhoods considerably.") );
  addItem( mLargeNetworkNeighborhoodItem, QStringLiteral( "LargeNetworkNeighborhood" ) );
  mMasterBrowsersRequireAuthItem = new KConfigSkeleton::ItemBool( currentGroup(), QStringLiteral( "MasterBrowsersRequireAuth" ), mMasterBrowsersRequireAuth, false );
  mMasterBrowsersRequireAuthItem->setLabel( i18nd("smb4k-core", "Master browsers require authentication") );
  mMasterBrowsersRequireAuthItem->setWhatsThis( i18nd("smb4k-core", "The master browsers in your network neighborhood require a login to return the browse list. This setting is rarely needed.") );
  addItem( mMasterBrowsersRequireAuthItem, QStringLiteral( "MasterBrowsersRequireAuth" ) );
  mUseKerberosItem = new KConfigSkeleton::ItemBool( currentGroup(), QStringLiteral( "UseKerberos" ), mUseKerberos, false );
  mUseKerberosItem->setLabel( i18nd("smb4k-core", "Use Kerberos for authentication") );
  mUseKerberosItem->setWhatsThis( i18nd("smb4k-core", "Use Kerberos for authentication. This is only useful in an Active Directory environment.") );
  addItem( mUseKerberosItem, QStringLiteral( "UseKerberos" ) );
  mUseWinbindCCacheItem = new KConfigSkeleton::ItemBool( currentGroup(), QStringLiteral( "UseWinbindCCache" ), mUseWinbindCCache, false );
  mUseWinbindCCacheItem->setLabel( i18nd("smb4k-core", "Use Winbind ccache for authentication") );
  mUseWinbindCCacheItem->setWhatsThis( i18nd("smb4k-core", "Use the Winbind ccache for authentication.") );
  addItem( mUseWinbindCCacheItem, QStringLiteral( "UseWinbindCCache" ) );
  mUseEncryptionLevelItem = new KConfigSkeleton::ItemBool( currentGroup(), QStringLiteral( "UseEncryptionLevel" ), mUseEncryptionLevel, false );
  mUseEncryptionLevelItem->setLabel( i18nd("smb4k-core", "Set the encryption level to:") );
  mUseEncryptionLevelItem->setWhatsThis( i18nd("smb4k-core", "Set the level of encryption that is used for making connections.") );
  addItem( mUseEncryptionLevelItem, QStringLiteral( "UseEncryptionLevel" ) );
  QList<KConfigSkeleton::ItemEnum::Choice> valuesEncryptionLevel;
  {
    KConfigSkeleton::ItemEnum::Choice choice;
    choice.name = QStringLiteral("None");
    choice.label = i18nd("smb4k-core", "None");
    valuesEncryptionLevel.append( choice );
  }
  {
    KConfigSkeleton::ItemEnum::Choice choice;
    choice.name = QStringLiteral("Request");
    choice.label = i18nd("smb4k-core", "Request");
    valuesEncryptionLevel.append( choice );
  }
  {
    KConfigSkeleton::ItemEnum::Choice choice;
    choice.name = QStringLiteral("Require");
    choice.label = i18nd("smb4k-core", "Require");
    valuesEncryptionLevel.append( choice );
  }
  mEncryptionLevelItem = new KConfigSkeleton::ItemEnum( currentGroup(), QStringLiteral( "EncryptionLevel" ), mEncryptionLevel, valuesEncryptionLevel, EnumEncryptionLevel::None );
  mEncryptionLevelItem->setLabel( i18nd("smb4k-core", "EncryptionLevel") );
  mEncryptionLevelItem->setWhatsThis( i18nd("smb4k-core", "Set the level of encryption that is used for making connections.") );
  addItem( mEncryptionLevelItem, QStringLiteral( "EncryptionLevel" ) );
  mPreviewHiddenItemsItem = new KConfigSkeleton::ItemBool( currentGroup(), QStringLiteral( "PreviewHiddenItems" ), mPreviewHiddenItems, false );
  mPreviewHiddenItemsItem->setLabel( i18nd("smb4k-core", "Preview hidden files and directories") );
  mPreviewHiddenItemsItem->setWhatsThis( i18nd("smb4k-core", "Preview hidden files and directories. The hidden files and directories are those whose names begin with a period. They are usually needed for very specific purposes (storing the configuration information for an application, etc.). Since they are not of any importance for your regular work, you normally do not need to enable this feature.") );
  addItem( mPreviewHiddenItemsItem, QStringLiteral( "PreviewHiddenItems" ) );
  mDetectPrinterSharesItem = new KConfigSkeleton::ItemBool( currentGroup(), QStringLiteral( "DetectPrinterShares" ), mDetectPrinterShares, true );
  mDetectPrinterSharesItem->setLabel( i18nd("smb4k-core", "Detect printer shares") );
  mDetectPrinterSharesItem->setWhatsThis( i18nd("smb4k-core", "Printer shares are detected.") );
  addItem( mDetectPrinterSharesItem, QStringLiteral( "DetectPrinterShares" ) );
  mDetectHiddenSharesItem = new KConfigSkeleton::ItemBool( currentGroup(), QStringLiteral( "DetectHiddenShares" ), mDetectHiddenShares, true );
  mDetectHiddenSharesItem->setLabel( i18nd("smb4k-core", "Detect hidden shares") );
  mDetectHiddenSharesItem->setWhatsThis( i18nd("smb4k-core", "Hidden shares are detected. Hidden shares are ending with a $ sign, e.g. Musik$ or IPC$.") );
  addItem( mDetectHiddenSharesItem, QStringLiteral( "DetectHiddenShares" ) );
  mEnableWakeOnLANItem = new KConfigSkeleton::ItemBool( currentGroup(), QStringLiteral( "EnableWakeOnLAN" ), mEnableWakeOnLAN, false );
  mEnableWakeOnLANItem->setLabel( i18nd("smb4k-core", "Enable Wake-On-LAN features") );
  mEnableWakeOnLANItem->setWhatsThis( i18nd("smb4k-core", "Wake-on-LAN (WOL) is an ethernet computer networking standard that allows a computer to be turned on or woken up by a network message. Smb4K uses a magic packet send via a UDP socket to wake up remote servers. If you want to take advantage of the Wake-On-LAN feature, you need to enable this option.") );
  addItem( mEnableWakeOnLANItem, QStringLiteral( "EnableWakeOnLAN" ) );
  mWakeOnLANWaitingTimeItem = new KConfigSkeleton::ItemInt( currentGroup(), QStringLiteral( "WakeOnLANWaitingTime" ), mWakeOnLANWaitingTime, 5 );
  mWakeOnLANWaitingTimeItem->setMinValue(0);
  mWakeOnLANWaitingTimeItem->setMaxValue(60);
  mWakeOnLANWaitingTimeItem->setLabel( i18nd("smb4k-core", "Waiting time:") );
  mWakeOnLANWaitingTimeItem->setWhatsThis( i18nd("smb4k-core", "This is the waiting time in seconds between the sending of the magic Wake-On-LAN packets and the scanning of the network neighborhood or the mounting of a share.") );
  addItem( mWakeOnLANWaitingTimeItem, QStringLiteral( "WakeOnLANWaitingTime" ) );

  setCurrentGroup( QStringLiteral( "Synchronization" ) );

  mRsyncPrefixItem = new KConfigSkeleton::ItemUrl( currentGroup(), QStringLiteral( "RsyncPrefix" ), mRsyncPrefix, QUrl::fromLocalFile(QDir::homePath() + QStringLiteral("/smb4k_sync/")) );
  mRsyncPrefixItem->setLabel( i18nd("smb4k-core", "Synchronization prefix:") );
  mRsyncPrefixItem->setWhatsThis( i18nd("smb4k-core", "Under this prefix the destination directory for the synchronization will be created. However, if you want to store the data of a particular share elsewhere, you will be able to choose a different path before the actual synchronization begins.") );
  addItem( mRsyncPrefixItem, QStringLiteral( "RsyncPrefix" ) );
  mArchiveModeItem = new KConfigSkeleton::ItemBool( currentGroup(), QStringLiteral( "ArchiveMode" ), mArchiveMode, true );
  mArchiveModeItem->setLabel( i18nd("smb4k-core", "Archive mode") );
  mArchiveModeItem->setWhatsThis( i18nd("smb4k-core", "Use archive mode (-a, --archive). This is a short form of -rlptgoD.") );
  addItem( mArchiveModeItem, QStringLiteral( "ArchiveMode" ) );
  mRecurseIntoDirectoriesItem = new KConfigSkeleton::ItemBool( currentGroup(), QStringLiteral( "RecurseIntoDirectories" ), mRecurseIntoDirectories, false );
  mRecurseIntoDirectoriesItem->setLabel( i18nd("smb4k-core", "Recurse into subdirectories") );
  mRecurseIntoDirectoriesItem->setWhatsThis( i18nd("smb4k-core", "Recurse into directories (-r, --recursive).") );
  addItem( mRecurseIntoDirectoriesItem, QStringLiteral( "RecurseIntoDirectories" ) );
  mUpdateTargetItem = new KConfigSkeleton::ItemBool( currentGroup(), QStringLiteral( "UpdateTarget" ), mUpdateTarget, false );
  mUpdateTargetItem->setLabel( i18nd("smb4k-core", "Update files") );
  mUpdateTargetItem->setWhatsThis( i18nd("smb4k-core", "Update files in the destination directory that are older than in the source directory (-u, --update).") );
  addItem( mUpdateTargetItem, QStringLiteral( "UpdateTarget" ) );
  mUpdateInPlaceItem = new KConfigSkeleton::ItemBool( currentGroup(), QStringLiteral( "UpdateInPlace" ), mUpdateInPlace, false );
  mUpdateInPlaceItem->setLabel( i18nd("smb4k-core", "Update files in place") );
  mUpdateInPlaceItem->setWhatsThis( i18nd("smb4k-core", "Update destination files in-place (--inplace). By default, rsync first creates a new copy of a file and moves it into place after its transfer finished. If you enable this feature, no copy will be created but the destination file will immediately be overwritten instead. An exception to this is if you combine this option with --backup.") );
  addItem( mUpdateInPlaceItem, QStringLiteral( "UpdateInPlace" ) );
  mRelativePathNamesItem = new KConfigSkeleton::ItemBool( currentGroup(), QStringLiteral( "RelativePathNames" ), mRelativePathNames, false );
  mRelativePathNamesItem->setLabel( i18nd("smb4k-core", "Use relative path names") );
  mRelativePathNamesItem->setWhatsThis( i18nd("smb4k-core", "Use relative paths (-R, --relative). This means that the full path names specified on the command line are sent to the server rather than just the last parts of the file names.") );
  addItem( mRelativePathNamesItem, QStringLiteral( "RelativePathNames" ) );
  mNoImpliedDirectoriesItem = new KConfigSkeleton::ItemBool( currentGroup(), QStringLiteral( "NoImpliedDirectories" ), mNoImpliedDirectories, false );
  mNoImpliedDirectoriesItem->setLabel( i18nd("smb4k-core", "Do not send implied directories") );
  mNoImpliedDirectoriesItem->setWhatsThis( i18nd("smb4k-core", "Do not send implied directories with --relative (--no-implied-dirs). This means that the corresponding path elements on the destination system are left unchanged if they exist, and any missing implied directories are created with default attributes. This even allows these implied path elements to have big differences, such as being a symlink to a directory on one side of the transfer, and a real directory on the other side.") );
  addItem( mNoImpliedDirectoriesItem, QStringLiteral( "NoImpliedDirectories" ) );
  mTransferDirectoriesItem = new KConfigSkeleton::ItemBool( currentGroup(), QStringLiteral( "TransferDirectories" ), mTransferDirectories, false );
  mTransferDirectoriesItem->setLabel( i18nd("smb4k-core", "Transfer directories without recursing") );
  mTransferDirectoriesItem->setWhatsThis( i18nd("smb4k-core", "Transfer directories without recursing (-d, --dirs). This means that all top-level subdirectories are transferred but without their contents.") );
  addItem( mTransferDirectoriesItem, QStringLiteral( "TransferDirectories" ) );
  mCompressDataItem = new KConfigSkeleton::ItemBool( currentGroup(), QStringLiteral( "CompressData" ), mCompressData, false );
  mCompressDataItem->setLabel( i18nd("smb4k-core", "Compress data during transfer") );
  mCompressDataItem->setWhatsThis( i18nd("smb4k-core", "Compress data during transfer (-z, --compress). This significantly reduces the amount of data that is being transferred. You may want to use this option, if you have a slow connection.") );
  addItem( mCompressDataItem, QStringLiteral( "CompressData" ) );
  mUseCompressionLevelItem = new KConfigSkeleton::ItemBool( currentGroup(), QStringLiteral( "UseCompressionLevel" ), mUseCompressionLevel, false );
  mUseCompressionLevelItem->setLabel( i18nd("smb4k-core", "Set compression level:") );
  mUseCompressionLevelItem->setWhatsThis( i18nd("smb4k-core", "Explicitly set the compression level to use (--compress-level=NUM). If NUM is non-zero, the --compress argument is implied.") );
  addItem( mUseCompressionLevelItem, QStringLiteral( "UseCompressionLevel" ) );
  mCompressionLevelItem = new KConfigSkeleton::ItemInt( currentGroup(), QStringLiteral( "CompressionLevel" ), mCompressionLevel, 0 );
  mCompressionLevelItem->setMinValue(0);
  mCompressionLevelItem->setMaxValue(9);
  mCompressionLevelItem->setLabel( i18nd("smb4k-core", "The value for the UseCompressionLevel config entry") );
  addItem( mCompressionLevelItem, QStringLiteral( "CompressionLevel" ) );
  mUseSkipCompressionItem = new KConfigSkeleton::ItemBool( currentGroup(), QStringLiteral( "UseSkipCompression" ), mUseSkipCompression, false );
  mUseSkipCompressionItem->setLabel( i18nd("smb4k-core", "Skip compression for following file suffixes:") );
  mUseSkipCompressionItem->setWhatsThis( i18nd("smb4k-core", "Overwrite the list of file suffixes that will not be compressed (--skip-compress=LIST). The LIST should be one or more file suffixes (without the dot) separated by slashes. You may specify an empty string to indicate that no file should be skipped. The default list of suffixes will be replaced by this list. For further details, see the manual page of rsync.") );
  addItem( mUseSkipCompressionItem, QStringLiteral( "UseSkipCompression" ) );
  mSkipCompressionItem = new KConfigSkeleton::ItemString( currentGroup(), QStringLiteral( "SkipCompression" ), mSkipCompression );
  mSkipCompressionItem->setLabel( i18nd("smb4k-core", "The value(s) for the UseSkipCompression config entry") );
  addItem( mSkipCompressionItem, QStringLiteral( "SkipCompression" ) );
  mPreserveSymlinksItem = new KConfigSkeleton::ItemBool( currentGroup(), QStringLiteral( "PreserveSymlinks" ), mPreserveSymlinks, false );
  mPreserveSymlinksItem->setLabel( i18nd("smb4k-core", "Preserve symlinks") );
  mPreserveSymlinksItem->setWhatsThis( i18nd("smb4k-core", "Copy symlinks as symlinks (-l, --links).") );
  addItem( mPreserveSymlinksItem, QStringLiteral( "PreserveSymlinks" ) );
  mTransformSymlinksItem = new KConfigSkeleton::ItemBool( currentGroup(), QStringLiteral( "TransformSymlinks" ), mTransformSymlinks, false );
  mTransformSymlinksItem->setLabel( i18nd("smb4k-core", "Transform symlinks") );
  mTransformSymlinksItem->setWhatsThis( i18nd("smb4k-core", "Transform symlinks into the items they are pointing to (-L, --copy-links).") );
  addItem( mTransformSymlinksItem, QStringLiteral( "TransformSymlinks" ) );
  mTransformUnsafeSymlinksItem = new KConfigSkeleton::ItemBool( currentGroup(), QStringLiteral( "TransformUnsafeSymlinks" ), mTransformUnsafeSymlinks, false );
  mTransformUnsafeSymlinksItem->setLabel( i18nd("smb4k-core", "Transform unsafe symlinks") );
  mTransformUnsafeSymlinksItem->setWhatsThis( i18nd("smb4k-core", "Transform unsafe symlinks into the items they are pointing to (--copy-unsafe-links). This means that only those symlinks are transformed that point to items that are outside the copied tree. Absolute symlinks are treated the same way. This option has no additional effect if --copy-links has also been specified.") );
  addItem( mTransformUnsafeSymlinksItem, QStringLiteral( "TransformUnsafeSymlinks" ) );
  mIgnoreUnsafeSymlinksItem = new KConfigSkeleton::ItemBool( currentGroup(), QStringLiteral( "IgnoreUnsafeSymlinks" ), mIgnoreUnsafeSymlinks, false );
  mIgnoreUnsafeSymlinksItem->setLabel( i18nd("smb4k-core", "Ignore unsafe symlinks") );
  mIgnoreUnsafeSymlinksItem->setWhatsThis( i18nd("smb4k-core", "Ignore symlinks that point outside the copied tree (--safe-links). All absolute symlinks are also ignored. If you use this option in conjunction with --relative you might get unexpected results.") );
  addItem( mIgnoreUnsafeSymlinksItem, QStringLiteral( "IgnoreUnsafeSymlinks" ) );
  mMungeSymlinksItem = new KConfigSkeleton::ItemBool( currentGroup(), QStringLiteral( "MungeSymlinks" ), mMungeSymlinks, false );
  mMungeSymlinksItem->setLabel( i18nd("smb4k-core", "Munge symlinks") );
  mMungeSymlinksItem->setWhatsThis( i18nd("smb4k-core", "This option tells rsync to (1) modify all symlinks on the receiving side in a way that makes them unusable but recoverable, or (2) to unmunge symlinks on the sending side that had been stored in a munged state (--munge-links). This is useful if you do not quite trust the source of the data to not try to slip in a symlink to an unexpected place. For more details, see the manual page of rsync.") );
  addItem( mMungeSymlinksItem, QStringLiteral( "MungeSymlinks" ) );
  mPreserveHardLinksItem = new KConfigSkeleton::ItemBool( currentGroup(), QStringLiteral( "PreserveHardLinks" ), mPreserveHardLinks, false );
  mPreserveHardLinksItem->setLabel( i18nd("smb4k-core", "Preserve hard links") );
  mPreserveHardLinksItem->setWhatsThis( i18nd("smb4k-core", "Preserve hard links (-H, --hard-links). This options causes rsync to preserve the hard links that are found during the transfer. Without it, hard links are treated as though they were separate files.") );
  addItem( mPreserveHardLinksItem, QStringLiteral( "PreserveHardLinks" ) );
  mCopyDirectorySymlinksItem = new KConfigSkeleton::ItemBool( currentGroup(), QStringLiteral( "CopyDirectorySymlinks" ), mCopyDirectorySymlinks, false );
  mCopyDirectorySymlinksItem->setLabel( i18nd("smb4k-core", "Copy directory symlinks") );
  mCopyDirectorySymlinksItem->setWhatsThis( i18nd("smb4k-core", "Treat symlinks to directories on the sending side as though they were real ones (-k, --copy-dirlinks). This is useful if you do not want symlinks to non-directories to be affected, as they would be using --copy-links. Without this option, if the sending side has replaced a directory with a symlink to a directory, the receiving side will delete anything that is in the way of the new symlink, including a directory hierarchy (as long as --force or --delete is in effect). For more details, see the manual page of rsync.") );
  addItem( mCopyDirectorySymlinksItem, QStringLiteral( "CopyDirectorySymlinks" ) );
  mKeepDirectorySymlinksItem = new KConfigSkeleton::ItemBool( currentGroup(), QStringLiteral( "KeepDirectorySymlinks" ), mKeepDirectorySymlinks, false );
  mKeepDirectorySymlinksItem->setLabel( i18nd("smb4k-core", "Keep directory symlinks") );
  mKeepDirectorySymlinksItem->setWhatsThis( i18nd("smb4k-core", "Treat symlinks to directories on the receiving side as though they were real ones (-K, --keep-dirlinks). This only works if the symlink matches a real directory from the sending side. Without this option, the receiver's symlink will be deleted and replaced with a real directory.") );
  addItem( mKeepDirectorySymlinksItem, QStringLiteral( "KeepDirectorySymlinks" ) );
  mPreservePermissionsItem = new KConfigSkeleton::ItemBool( currentGroup(), QStringLiteral( "PreservePermissions" ), mPreservePermissions, false );
  mPreservePermissionsItem->setLabel( i18nd("smb4k-core", "Preserve permissions") );
  mPreservePermissionsItem->setWhatsThis( i18nd("smb4k-core", "Preserve permissions (-p, --perms). The permissions of the destination file will be same as the source file. For what happens if this option is switched off, please read rsync's manual page.") );
  addItem( mPreservePermissionsItem, QStringLiteral( "PreservePermissions" ) );
  mPreserveACLsItem = new KConfigSkeleton::ItemBool( currentGroup(), QStringLiteral( "PreserveACLs" ), mPreserveACLs, false );
  mPreserveACLsItem->setLabel( i18nd("smb4k-core", "Preserve access control lists (ACLs)") );
  mPreserveACLsItem->setWhatsThis( i18nd("smb4k-core", "Preserve access control lists. This option causes rsync to update the destination ACLs to be the same as the source ACLs. The option also implies --perms. The source and destination systems must have compatible ACL entries for this option to work properly.") );
  addItem( mPreserveACLsItem, QStringLiteral( "PreserveACLs" ) );
  mPreserveExtendedAttributesItem = new KConfigSkeleton::ItemBool( currentGroup(), QStringLiteral( "PreserveExtendedAttributes" ), mPreserveExtendedAttributes, false );
  mPreserveExtendedAttributesItem->setLabel( i18nd("smb4k-core", "Preserve extended attributes") );
  mPreserveExtendedAttributesItem->setWhatsThis( i18nd("smb4k-core", "Preserve extended attributes. This option causes rsync to update the destination extended attributes to be the same as the source ones.") );
  addItem( mPreserveExtendedAttributesItem, QStringLiteral( "PreserveExtendedAttributes" ) );
  mPreserveAccessTimesItem = new KConfigSkeleton::ItemBool( currentGroup(), QStringLiteral( "PreserveAccessTimes" ), mPreserveAccessTimes, false );
  mPreserveAccessTimesItem->setLabel( i18nd("smb4k-core", "Preserve access times") );
  mPreserveAccessTimesItem->setWhatsThis( i18nd("smb4k-core", "Preserve access times. This tells rsync to set the access (use) times of the destination files to the same value as the source files.") );
  addItem( mPreserveAccessTimesItem, QStringLiteral( "PreserveAccessTimes" ) );
  mPreserveCreateTimesItem = new KConfigSkeleton::ItemBool( currentGroup(), QStringLiteral( "PreserveCreateTimes" ), mPreserveCreateTimes, false );
  mPreserveCreateTimesItem->setLabel( i18nd("smb4k-core", "Preserve create times") );
  mPreserveCreateTimesItem->setWhatsThis( i18nd("smb4k-core", "Preserve create times. This tells rsync to set the create times (newness) of the destination files to the same value as the source files.") );
  addItem( mPreserveCreateTimesItem, QStringLiteral( "PreserveCreateTimes" ) );
  mPreserveGroupItem = new KConfigSkeleton::ItemBool( currentGroup(), QStringLiteral( "PreserveGroup" ), mPreserveGroup, false );
  mPreserveGroupItem->setLabel( i18nd("smb4k-core", "Preserve group") );
  mPreserveGroupItem->setWhatsThis( i18nd("smb4k-core", "Preserve the group (-g, --group). The group of the destination file will be set to the same value as the source file.") );
  addItem( mPreserveGroupItem, QStringLiteral( "PreserveGroup" ) );
  mPreserveOwnerItem = new KConfigSkeleton::ItemBool( currentGroup(), QStringLiteral( "PreserveOwner" ), mPreserveOwner, false );
  mPreserveOwnerItem->setLabel( i18nd("smb4k-core", "Preserve owner") );
  mPreserveOwnerItem->setWhatsThis( i18nd("smb4k-core", "Preserve the owner (-o, --owner). The owner of the destination file will be set to the same value as the source file, but only if the receiving rsync is run as the super user. Without this option, the owner is set to the invoking user on the receiving side.") );
  addItem( mPreserveOwnerItem, QStringLiteral( "PreserveOwner" ) );
  mPreserveDevicesAndSpecialsItem = new KConfigSkeleton::ItemBool( currentGroup(), QStringLiteral( "PreserveDevicesAndSpecials" ), mPreserveDevicesAndSpecials, false );
  mPreserveDevicesAndSpecialsItem->setLabel( i18nd("smb4k-core", "Preserve device and special files") );
  mPreserveDevicesAndSpecialsItem->setWhatsThis( i18nd("smb4k-core", "Preserve device and special files (-D, --devices --specials). This option causes rsync to transfer character and block devices as well as special files such as named sockets and fifos. It works only partially if rsync is not run as super user and the --super option is not specified.") );
  addItem( mPreserveDevicesAndSpecialsItem, QStringLiteral( "PreserveDevicesAndSpecials" ) );
  mPreserveTimesItem = new KConfigSkeleton::ItemBool( currentGroup(), QStringLiteral( "PreserveTimes" ), mPreserveTimes, false );
  mPreserveTimesItem->setLabel( i18nd("smb4k-core", "Preserve times") );
  mPreserveTimesItem->setWhatsThis( i18nd("smb4k-core", "Preserve times (-t, --times). The modification times are transferred along with the files. For what happens if this option is switched off, please read rsync's manual page.") );
  addItem( mPreserveTimesItem, QStringLiteral( "PreserveTimes" ) );
  mOmitDirectoryTimesItem = new KConfigSkeleton::ItemBool( currentGroup(), QStringLiteral( "OmitDirectoryTimes" ), mOmitDirectoryTimes, false );
  mOmitDirectoryTimesItem->setLabel( i18nd("smb4k-core", "Omit directories when preserving times") );
  mOmitDirectoryTimesItem->setWhatsThis( i18nd("smb4k-core", "Omit directories when preserving times (-O, --omit-dir-times). This means that directories are omitted when modification times are being preserved. Thus, this feature only works in conjunction with --times.") );
  addItem( mOmitDirectoryTimesItem, QStringLiteral( "OmitDirectoryTimes" ) );
  mRemoveSourceFilesItem = new KConfigSkeleton::ItemBool( currentGroup(), QStringLiteral( "RemoveSourceFiles" ), mRemoveSourceFiles, false );
  mRemoveSourceFilesItem->setLabel( i18nd("smb4k-core", "Remove synchronized source files") );
  mRemoveSourceFilesItem->setWhatsThis( i18nd("smb4k-core", "Remove all synchronized source files (--remove-source-files). This tells rsync to remove from the sending side the non-directory items that are a part of the transfer and have been successfully duplicated on the receiving side.") );
  addItem( mRemoveSourceFilesItem, QStringLiteral( "RemoveSourceFiles" ) );
  mDeleteExtraneousItem = new KConfigSkeleton::ItemBool( currentGroup(), QStringLiteral( "DeleteExtraneous" ), mDeleteExtraneous, false );
  mDeleteExtraneousItem->setLabel( i18nd("smb4k-core", "Delete extraneous files") );
  mDeleteExtraneousItem->setWhatsThis( i18nd("smb4k-core", "Delete extraneous files from destination (--delete). This tells rsync to delete all files from the receiving side that are not present on the sending side, but only for the directories that are being synchronized.") );
  addItem( mDeleteExtraneousItem, QStringLiteral( "DeleteExtraneous" ) );
  mDeleteBeforeItem = new KConfigSkeleton::ItemBool( currentGroup(), QStringLiteral( "DeleteBefore" ), mDeleteBefore, false );
  mDeleteBeforeItem->setLabel( i18nd("smb4k-core", "Delete files before transfer") );
  mDeleteBeforeItem->setWhatsThis( i18nd("smb4k-core", "Delete files on the receiving side before the transfer starts (--delete-before). This is the default behavior if --delete or --delete-excluded is specified without one of the --delete-WHEN options.") );
  addItem( mDeleteBeforeItem, QStringLiteral( "DeleteBefore" ) );
  mDeleteAfterItem = new KConfigSkeleton::ItemBool( currentGroup(), QStringLiteral( "DeleteAfter" ), mDeleteAfter, false );
  mDeleteAfterItem->setLabel( i18nd("smb4k-core", "Delete files after transfer") );
  mDeleteAfterItem->setWhatsThis( i18nd("smb4k-core", "Delete files on the receiving side after the transfer has completed (--delete-after, --del).") );
  addItem( mDeleteAfterItem, QStringLiteral( "DeleteAfter" ) );
  mDeleteDuringItem = new KConfigSkeleton::ItemBool( currentGroup(), QStringLiteral( "DeleteDuring" ), mDeleteDuring, false );
  mDeleteDuringItem->setLabel( i18nd("smb4k-core", "Delete files during transfer") );
  mDeleteDuringItem->setWhatsThis( i18nd("smb4k-core", "Delete files on the receiving side during the transfer (--delete-during). This method is faster than --delete-before or --delete-after, but it is only supported with rsync 2.6.4 or later.") );
  addItem( mDeleteDuringItem, QStringLiteral( "DeleteDuring" ) );
  mDeleteExcludedItem = new KConfigSkeleton::ItemBool( currentGroup(), QStringLiteral( "DeleteExcluded" ), mDeleteExcluded, false );
  mDeleteExcludedItem->setLabel( i18nd("smb4k-core", "Delete excluded files") );
  mDeleteExcludedItem->setWhatsThis( i18nd("smb4k-core", "Also delete excluded files from destination directory (--delete-excluded). In addition to deleting the files on the receiving side that are not on the sending side, this tells rsync to also delete any files on the receiving side that are excluded. Refer to rsync's manual page for further information.") );
  addItem( mDeleteExcludedItem, QStringLiteral( "DeleteExcluded" ) );
  mIgnoreErrorsItem = new KConfigSkeleton::ItemBool( currentGroup(), QStringLiteral( "IgnoreErrors" ), mIgnoreErrors, false );
  mIgnoreErrorsItem->setLabel( i18nd("smb4k-core", "Delete even if I/O errors occur") );
  mIgnoreErrorsItem->setWhatsThis( i18nd("smb4k-core", "Delete even if I/O errors occur (--ignore-errors). This option has to be specified in conjunction with --delete to take effect.") );
  addItem( mIgnoreErrorsItem, QStringLiteral( "IgnoreErrors" ) );
  mForceDirectoryDeletionItem = new KConfigSkeleton::ItemBool( currentGroup(), QStringLiteral( "ForceDirectoryDeletion" ), mForceDirectoryDeletion, false );
  mForceDirectoryDeletionItem->setLabel( i18nd("smb4k-core", "Force deletion of non-void directories") );
  mForceDirectoryDeletionItem->setWhatsThis( i18nd("smb4k-core", "Force deletion of directories even if they are not empty (--force). This option tells rsync to delete a non-empty directory when it is to be replaced by a non-directory. This is only relevant if deletions are not active.") );
  addItem( mForceDirectoryDeletionItem, QStringLiteral( "ForceDirectoryDeletion" ) );
  mUseMaximumDeleteItem = new KConfigSkeleton::ItemBool( currentGroup(), QStringLiteral( "UseMaximumDelete" ), mUseMaximumDelete, false );
  mUseMaximumDeleteItem->setLabel( i18nd("smb4k-core", "Do not delete more than this many files:") );
  mUseMaximumDeleteItem->setWhatsThis( i18nd("smb4k-core", "Only delete as many files as defined here (--max-delete=NUM). This tells rsync not to delete more than NUM files or directories (NUM must be non-zero). This is useful when mirroring very large trees to prevent disasters.") );
  addItem( mUseMaximumDeleteItem, QStringLiteral( "UseMaximumDelete" ) );
  mMaximumDeleteValueItem = new KConfigSkeleton::ItemInt( currentGroup(), QStringLiteral( "MaximumDeleteValue" ), mMaximumDeleteValue, 0 );
  mMaximumDeleteValueItem->setMinValue(0);
  mMaximumDeleteValueItem->setLabel( i18nd("smb4k-core", "Value for DeleteMaximum config entry") );
  addItem( mMaximumDeleteValueItem, QStringLiteral( "MaximumDeleteValue" ) );
  mUseMinimalTransferSizeItem = new KConfigSkeleton::ItemBool( currentGroup(), QStringLiteral( "UseMinimalTransferSize" ), mUseMinimalTransferSize, false );
  mUseMinimalTransferSizeItem->setLabel( i18nd("smb4k-core", "Do not transfer any file smaller than:") );
  mUseMinimalTransferSizeItem->setWhatsThis( i18nd("smb4k-core", "This option causes rsync to not transfer any file that is smaller than the specified size (--min-size=SIZE).") );
  addItem( mUseMinimalTransferSizeItem, QStringLiteral( "UseMinimalTransferSize" ) );
  mMinimalTransferSizeItem = new KConfigSkeleton::ItemInt( currentGroup(), QStringLiteral( "MinimalTransferSize" ), mMinimalTransferSize, 0 );
  mMinimalTransferSizeItem->setMinValue(0);
  mMinimalTransferSizeItem->setLabel( i18nd("smb4k-core", "Value for MinimalTransferSize config entry") );
  addItem( mMinimalTransferSizeItem, QStringLiteral( "MinimalTransferSize" ) );
  mUseMaximalTransferSizeItem = new KConfigSkeleton::ItemBool( currentGroup(), QStringLiteral( "UseMaximalTransferSize" ), mUseMaximalTransferSize, false );
  mUseMaximalTransferSizeItem->setLabel( i18nd("smb4k-core", "Do not transfer any file larger than:") );
  mUseMaximalTransferSizeItem->setWhatsThis( i18nd("smb4k-core", "This option causes rsync to not transfer any file that is larger than the specified size (--max-size=SIZE).") );
  addItem( mUseMaximalTransferSizeItem, QStringLiteral( "UseMaximalTransferSize" ) );
  mMaximalTransferSizeItem = new KConfigSkeleton::ItemInt( currentGroup(), QStringLiteral( "MaximalTransferSize" ), mMaximalTransferSize, 0 );
  mMaximalTransferSizeItem->setMinValue(0);
  mMaximalTransferSizeItem->setLabel( i18nd("smb4k-core", "Value for MaximalTransferSize config entry") );
  addItem( mMaximalTransferSizeItem, QStringLiteral( "MaximalTransferSize" ) );
  mKeepPartialItem = new KConfigSkeleton::ItemBool( currentGroup(), QStringLiteral( "KeepPartial" ), mKeepPartial, false );
  mKeepPartialItem->setLabel( i18nd("smb4k-core", "Keep partially transferred files") );
  mKeepPartialItem->setWhatsThis( i18nd("smb4k-core", "Keep partially transferred files (--partial). The default behavior is that any partially transferred file is deleted if the transfer is interrupted.") );
  addItem( mKeepPartialItem, QStringLiteral( "KeepPartial" ) );
  mUsePartialDirectoryItem = new KConfigSkeleton::ItemBool( currentGroup(), QStringLiteral( "UsePartialDirectory" ), mUsePartialDirectory, false );
  mUsePartialDirectoryItem->setLabel( i18nd("smb4k-core", "Put partially transferred files into:") );
  mUsePartialDirectoryItem->setWhatsThis( i18nd("smb4k-core", "Put a partially transferred file into this directory (--partial-dir=DIR). This is a better way than the --partial option to keep partial files, because the partially transferred file is kept in a different directory and the destination file is not overwritten.") );
  addItem( mUsePartialDirectoryItem, QStringLiteral( "UsePartialDirectory" ) );
  mPartialDirectoryItem = new KConfigSkeleton::ItemUrl( currentGroup(), QStringLiteral( "PartialDirectory" ), mPartialDirectory, QUrl::fromLocalFile(QDir::homePath()) );
  mPartialDirectoryItem->setLabel( i18nd("smb4k-core", "The data for the UsePartialDirectory option") );
  addItem( mPartialDirectoryItem, QStringLiteral( "PartialDirectory" ) );
  mUseCVSExcludeItem = new KConfigSkeleton::ItemBool( currentGroup(), QStringLiteral( "UseCVSExclude" ), mUseCVSExclude, false );
  mUseCVSExcludeItem->setLabel( i18nd("smb4k-core", "Auto-ignore files in the same way CVS does") );
  mUseCVSExcludeItem->setWhatsThis( i18nd("smb4k-core", "Auto-ignore files in the same way CVS does (-C, --cvs-exclude). This is a useful shorthand for excluding a broad range of files that you often do not want to transfer between systems. This option uses the same algorithm that CVS uses to determine if a file should be ignored.") );
  addItem( mUseCVSExcludeItem, QStringLiteral( "UseCVSExclude" ) );
  mUseExcludePatternItem = new KConfigSkeleton::ItemBool( currentGroup(), QStringLiteral( "UseExcludePattern" ), mUseExcludePattern, false );
  mUseExcludePatternItem->setLabel( i18nd("smb4k-core", "Exclude files matching this pattern:") );
  mUseExcludePatternItem->setWhatsThis( i18nd("smb4k-core", "Exclude files that match a certain pattern (--exclude=PATTERN). This is a special filter rule. For further information on filter rules see rsync's manual page.") );
  addItem( mUseExcludePatternItem, QStringLiteral( "UseExcludePattern" ) );
  mExcludePatternItem = new KConfigSkeleton::ItemString( currentGroup(), QStringLiteral( "ExcludePattern" ), mExcludePattern );
  mExcludePatternItem->setLabel( i18nd("smb4k-core", "Pattern that is used for file exclusion") );
  addItem( mExcludePatternItem, QStringLiteral( "ExcludePattern" ) );
  mUseExcludeFromItem = new KConfigSkeleton::ItemBool( currentGroup(), QStringLiteral( "UseExcludeFrom" ), mUseExcludeFrom, false );
  mUseExcludeFromItem->setLabel( i18nd("smb4k-core", "Read exclude patterns from:") );
  mUseExcludeFromItem->setWhatsThis( i18nd("smb4k-core", "Read exclude patterns from a file (--exclude-from=FILE). This option is similar to the --exclude=PATTERN option except that the exclude patterns are read from a file. This is a special filter rule. For further information on filter rules see rsync's manual page.") );
  addItem( mUseExcludeFromItem, QStringLiteral( "UseExcludeFrom" ) );
  mExcludeFromItem = new KConfigSkeleton::ItemUrl( currentGroup(), QStringLiteral( "ExcludeFrom" ), mExcludeFrom, QUrl::fromLocalFile(QDir::homePath() + QStringLiteral("/exclude.txt")) );
  mExcludeFromItem->setLabel( i18nd("smb4k-core", "The file from which the exclude patterns are read") );
  addItem( mExcludeFromItem, QStringLiteral( "ExcludeFrom" ) );
  mUseIncludePatternItem = new KConfigSkeleton::ItemBool( currentGroup(), QStringLiteral( "UseIncludePattern" ), mUseIncludePattern, false );
  mUseIncludePatternItem->setLabel( i18nd("smb4k-core", "Include files matching this pattern:") );
  mUseIncludePatternItem->setWhatsThis( i18nd("smb4k-core", "Do not exclude files matching a certain pattern (--include=PATTERN). This is a special filter rule. For further information on filter rules see rsync's manual page.") );
  addItem( mUseIncludePatternItem, QStringLiteral( "UseIncludePattern" ) );
  mIncludePatternItem = new KConfigSkeleton::ItemString( currentGroup(), QStringLiteral( "IncludePattern" ), mIncludePattern );
  mIncludePatternItem->setLabel( i18nd("smb4k-core", "Pattern that is used for file inclusion") );
  addItem( mIncludePatternItem, QStringLiteral( "IncludePattern" ) );
  mUseIncludeFromItem = new KConfigSkeleton::ItemBool( currentGroup(), QStringLiteral( "UseIncludeFrom" ), mUseIncludeFrom, false );
  mUseIncludeFromItem->setLabel( i18nd("smb4k-core", "Read include patterns from:") );
  mUseIncludeFromItem->setWhatsThis( i18nd("smb4k-core", "Read include patterns from a file (--include-from=FILE). This option is similar to the --include=PATTERN option except that the include patterns are read from a file. This is a special filter rule. For further information on filter rules see rsync's manual page.") );
  addItem( mUseIncludeFromItem, QStringLiteral( "UseIncludeFrom" ) );
  mIncludeFromItem = new KConfigSkeleton::ItemUrl( currentGroup(), QStringLiteral( "IncludeFrom" ), mIncludeFrom, QUrl::fromLocalFile(QDir::homePath() + QStringLiteral("/include.txt")) );
  mIncludeFromItem->setLabel( i18nd("smb4k-core", "The file from which the include patterns are read") );
  addItem( mIncludeFromItem, QStringLiteral( "IncludeFrom" ) );
  mUseCustomFilteringRulesItem = new KConfigSkeleton::ItemBool( currentGroup(), QStringLiteral( "UseCustomFilteringRules" ), mUseCustomFilteringRules, false );
  mUseCustomFilteringRulesItem->setLabel( i18nd("smb4k-core", "Custom filter rules:") );
  mUseCustomFilteringRulesItem->setWhatsThis( i18nd("smb4k-core", "Add custom file-filtering rules (-f, --filter=RULE). This option allows you to add rules to selectively exclude certain files from the list of files to be transferred. These rules will be added to the rsync command as they are. Thus, each rule has to start with the --filter=... argument.") );
  addItem( mUseCustomFilteringRulesItem, QStringLiteral( "UseCustomFilteringRules" ) );
  mCustomFilteringRulesItem = new KConfigSkeleton::ItemString( currentGroup(), QStringLiteral( "CustomFilteringRules" ), mCustomFilteringRules );
  mCustomFilteringRulesItem->setLabel( i18nd("smb4k-core", "Custom filter rules") );
  addItem( mCustomFilteringRulesItem, QStringLiteral( "CustomFilteringRules" ) );
  mUseFFilterRuleItem = new KConfigSkeleton::ItemBool( currentGroup(), QStringLiteral( "UseFFilterRule" ), mUseFFilterRule, false );
  mUseFFilterRuleItem->setLabel( i18nd("smb4k-core", "Use --filter='dir-merge /.rsync-filter' filter rule") );
  mUseFFilterRuleItem->setWhatsThis( i18nd("smb4k-core", "This filter rule tells rsync to look for per-directory .rsync-filter files that have been sprinkled through the hierarchy and use their rules to filter the files in the transfer. It has no effect, if you also choose to use the --filter='exclude .rsync-filter' rule.") );
  addItem( mUseFFilterRuleItem, QStringLiteral( "UseFFilterRule" ) );
  mUseFFFilterRuleItem = new KConfigSkeleton::ItemBool( currentGroup(), QStringLiteral( "UseFFFilterRule" ), mUseFFFilterRule, false );
  mUseFFFilterRuleItem->setLabel( i18nd("smb4k-core", "Use --filter='exclude .rsync-filter' filter rule") );
  mUseFFFilterRuleItem->setWhatsThis( i18nd("smb4k-core", "This rule filters out the .rsync-filter files from the transfer. These files normally contain filter rules that can be activated by choosing the --filter='dir-merge /.rsync-filter' rule and deselecting this one.") );
  addItem( mUseFFFilterRuleItem, QStringLiteral( "UseFFFilterRule" ) );
  mEfficientSparseFileHandlingItem = new KConfigSkeleton::ItemBool( currentGroup(), QStringLiteral( "EfficientSparseFileHandling" ), mEfficientSparseFileHandling, false );
  mEfficientSparseFileHandlingItem->setLabel( i18nd("smb4k-core", "Handle sparse files efficiently") );
  mEfficientSparseFileHandlingItem->setWhatsThis( i18nd("smb4k-core", "Handle sparse files efficiently (-S, --sparse) so that they take up less space on the destination. This option conflicts with --inplace. For further information read rsync's manual page.") );
  addItem( mEfficientSparseFileHandlingItem, QStringLiteral( "EfficientSparseFileHandling" ) );
  mCopyFilesWholeItem = new KConfigSkeleton::ItemBool( currentGroup(), QStringLiteral( "CopyFilesWhole" ), mCopyFilesWhole, false );
  mCopyFilesWholeItem->setLabel( i18nd("smb4k-core", "Copy files whole (no rsync algorithm)") );
  mCopyFilesWholeItem->setWhatsThis( i18nd("smb4k-core", "Copy files whole (-W, --whole-file). With this option the incremental rsync algorithm is not used and the whole file is sent as-is instead.") );
  addItem( mCopyFilesWholeItem, QStringLiteral( "CopyFilesWhole" ) );
  mOneFileSystemItem = new KConfigSkeleton::ItemBool( currentGroup(), QStringLiteral( "OneFileSystem" ), mOneFileSystem, false );
  mOneFileSystemItem->setLabel( i18nd("smb4k-core", "Do not cross file system boundaries") );
  mOneFileSystemItem->setWhatsThis( i18nd("smb4k-core", "Do not cross file system boundaries (-x, --one-file-system). This tells rsync to avoid crossing a filesystem boundary when recursing. For further information on this option, read the manual page.") );
  addItem( mOneFileSystemItem, QStringLiteral( "OneFileSystem" ) );
  mUpdateExistingItem = new KConfigSkeleton::ItemBool( currentGroup(), QStringLiteral( "UpdateExisting" ), mUpdateExisting, false );
  mUpdateExistingItem->setLabel( i18nd("smb4k-core", "Only update files that already exist") );
  mUpdateExistingItem->setWhatsThis( i18nd("smb4k-core", "Skip creating new files on the receiving side (--existing). This tells rsync to skip creating files (including directories) that do not exist yet on the destination. If this option is combined with the --ignore-existing option, no files will be updated (which can be useful if all you want to do is to delete extraneous files).") );
  addItem( mUpdateExistingItem, QStringLiteral( "UpdateExisting" ) );
  mIgnoreExistingItem = new KConfigSkeleton::ItemBool( currentGroup(), QStringLiteral( "IgnoreExisting" ), mIgnoreExisting, false );
  mIgnoreExistingItem->setLabel( i18nd("smb4k-core", "Ignore files that already exist") );
  mIgnoreExistingItem->setWhatsThis( i18nd("smb4k-core", "Skip updating files that already exist on the receiving side (--ignore-existing). Existing directories are not ignored.") );
  addItem( mIgnoreExistingItem, QStringLiteral( "IgnoreExisting" ) );
  mDelayUpdatesItem = new KConfigSkeleton::ItemBool( currentGroup(), QStringLiteral( "DelayUpdates" ), mDelayUpdates, false );
  mDelayUpdatesItem->setLabel( i18nd("smb4k-core", "Delay updates until the end of transfer") );
  mDelayUpdatesItem->setWhatsThis( i18nd("smb4k-core", "Delay updates until the end of the transfer (--delay-updates). This option puts the temporary file from each updated file into a holding directory until the end of the transfer, at which time all the files are renamed and copied into place in rapid succession.") );
  addItem( mDelayUpdatesItem, QStringLiteral( "DelayUpdates" ) );
  mMakeBackupsItem = new KConfigSkeleton::ItemBool( currentGroup(), QStringLiteral( "MakeBackups" ), mMakeBackups, false );
  mMakeBackupsItem->setLabel( i18nd("smb4k-core", "Make backups") );
  mMakeBackupsItem->setWhatsThis( i18nd("smb4k-core", "Make backups (-b, --backup). With this option, preexisting destination files are renamed as each file is transferred or deleted. You can control where the backup file goes and what (if any) suffix gets appended using the --backup-dir=DIR and --suffix=SUFFIX options.") );
  addItem( mMakeBackupsItem, QStringLiteral( "MakeBackups" ) );
  mUseBackupSuffixItem = new KConfigSkeleton::ItemBool( currentGroup(), QStringLiteral( "UseBackupSuffix" ), mUseBackupSuffix, false );
  mUseBackupSuffixItem->setLabel( i18nd("smb4k-core", "Backup suffix:") );
  mUseBackupSuffixItem->setWhatsThis( i18nd("smb4k-core", "Use this suffix for backups (--suffix=SUFFIX).") );
  addItem( mUseBackupSuffixItem, QStringLiteral( "UseBackupSuffix" ) );
  mBackupSuffixItem = new KConfigSkeleton::ItemString( currentGroup(), QStringLiteral( "BackupSuffix" ), mBackupSuffix, QStringLiteral( "~" ) );
  mBackupSuffixItem->setLabel( i18nd("smb4k-core", "Backup suffix") );
  addItem( mBackupSuffixItem, QStringLiteral( "BackupSuffix" ) );
  mUseBackupDirectoryItem = new KConfigSkeleton::ItemBool( currentGroup(), QStringLiteral( "UseBackupDirectory" ), mUseBackupDirectory, false );
  mUseBackupDirectoryItem->setLabel( i18nd("smb4k-core", "Backup directory:") );
  mUseBackupDirectoryItem->setWhatsThis( i18nd("smb4k-core", "Store backups in this directory (--backup-dir=DIR).") );
  addItem( mUseBackupDirectoryItem, QStringLiteral( "UseBackupDirectory" ) );
  mBackupDirectoryItem = new KConfigSkeleton::ItemUrl( currentGroup(), QStringLiteral( "BackupDirectory" ), mBackupDirectory, QUrl::fromLocalFile(QDir::homePath()) );
  mBackupDirectoryItem->setLabel( i18nd("smb4k-core", "Backup directory") );
  addItem( mBackupDirectoryItem, QStringLiteral( "BackupDirectory" ) );
  mUseBlockSizeItem = new KConfigSkeleton::ItemBool( currentGroup(), QStringLiteral( "UseBlockSize" ), mUseBlockSize, false );
  mUseBlockSizeItem->setLabel( i18nd("smb4k-core", "Force fixed checksum block size:") );
  mUseBlockSizeItem->setWhatsThis( i18nd("smb4k-core", "Force a fixed checksum block-size (-B, --block-size=SIZE). This forces the block size used in the rsync algorithm to a fixed value.") );
  addItem( mUseBlockSizeItem, QStringLiteral( "UseBlockSize" ) );
  mBlockSizeItem = new KConfigSkeleton::ItemInt( currentGroup(), QStringLiteral( "BlockSize" ), mBlockSize, 0 );
  mBlockSizeItem->setMinValue(0);
  mBlockSizeItem->setLabel( i18nd("smb4k-core", "The block size") );
  addItem( mBlockSizeItem, QStringLiteral( "BlockSize" ) );
  mUseChecksumSeedItem = new KConfigSkeleton::ItemBool( currentGroup(), QStringLiteral( "UseChecksumSeed" ), mUseChecksumSeed, false );
  mUseChecksumSeedItem->setLabel( i18nd("smb4k-core", "Set block/file checksum seed:") );
  mUseChecksumSeedItem->setWhatsThis( i18nd("smb4k-core", "Set block/file checksum seed (--checksum-seed=NUM). Set the MD4 checksum seed to this integer. This 4 byte checksum seed is included in each block and file MD4 checksum calculation. By default the checksum seed is generated by the server and defaults to the current time.") );
  addItem( mUseChecksumSeedItem, QStringLiteral( "UseChecksumSeed" ) );
  mChecksumSeedItem = new KConfigSkeleton::ItemInt( currentGroup(), QStringLiteral( "ChecksumSeed" ), mChecksumSeed, 0 );
  mChecksumSeedItem->setMinValue(0);
  mChecksumSeedItem->setLabel( i18nd("smb4k-core", "The value for the UseChecksumSeed config option") );
  addItem( mChecksumSeedItem, QStringLiteral( "ChecksumSeed" ) );
  mUseChecksumItem = new KConfigSkeleton::ItemBool( currentGroup(), QStringLiteral( "UseChecksum" ), mUseChecksum, false );
  mUseChecksumItem->setLabel( i18nd("smb4k-core", "Skip files based on checksum") );
  mUseChecksumItem->setWhatsThis( i18nd("smb4k-core", "Skip files based on a checksum and not based on modification time and size (-c, --checksum). For further information on how this feature works read rsync's manual page.") );
  addItem( mUseChecksumItem, QStringLiteral( "UseChecksum" ) );
  mUseBandwidthLimitItem = new KConfigSkeleton::ItemBool( currentGroup(), QStringLiteral( "UseBandwidthLimit" ), mUseBandwidthLimit, false );
  mUseBandwidthLimitItem->setLabel( i18nd("smb4k-core", "Set bandwidth limit:") );
  mUseBandwidthLimitItem->setWhatsThis( i18nd("smb4k-core", "Set the maximum data transfer rate in kilobytes per second (--bwlimit=RATE).") );
  addItem( mUseBandwidthLimitItem, QStringLiteral( "UseBandwidthLimit" ) );
  mBandwidthLimitItem = new KConfigSkeleton::ItemInt( currentGroup(), QStringLiteral( "BandwidthLimit" ), mBandwidthLimit, 0 );
  mBandwidthLimitItem->setMinValue(0);
  mBandwidthLimitItem->setMaxValue(1073741824);
  mBandwidthLimitItem->setLabel( i18nd("smb4k-core", "The value for the UseBandwidthLimit config option") );
  addItem( mBandwidthLimitItem, QStringLiteral( "BandwidthLimit" ) );

  setCurrentGroup( QStringLiteral( "Profiles" ) );

  mUseProfilesItem = new KConfigSkeleton::ItemBool( currentGroup(), QStringLiteral( "UseProfiles" ), mUseProfiles, false );
  mUseProfilesItem->setLabel( i18nd("smb4k-core", "Use profiles") );
  mUseProfilesItem->setWhatsThis( i18nd("smb4k-core", "Make Smb4K use profiles. This enables you to define different bookmarks and custom options for each profile. This is especially useful if you are using a laptop in different network neighborhoods, e. g. at home and at work.") );
  addItem( mUseProfilesItem, QStringLiteral( "UseProfiles" ) );

                QStringList defaultProfiles;
                defaultProfiles.append(i18nc("default profile name for use at home", "Home"));
                defaultProfiles.append(i18nc("default profile name for use at work", "Work"));
            
  mProfilesListItem = new KConfigSkeleton::ItemStringList( currentGroup(), QStringLiteral( "ProfilesList" ), mProfilesList, defaultProfiles );
  mProfilesListItem->setLabel( i18nd("smb4k-core", "Profiles") );
  mProfilesListItem->setWhatsThis( i18nd("smb4k-core", "The list of profiles.") );
  addItem( mProfilesListItem, QStringLiteral( "ProfilesList" ) );
  mActiveProfileItem = new KConfigSkeleton::ItemString( currentGroup(), QStringLiteral( "ActiveProfile" ), mActiveProfile, QString() );
  mActiveProfileItem->setLabel( i18nd("smb4k-core", "Active profile") );
  mActiveProfileItem->setWhatsThis( i18nd("smb4k-core", "This is the currently active profile.") );
  addItem( mActiveProfileItem, QStringLiteral( "ActiveProfile" ) );
}

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

