FreeCAD / src /Gui /PreferencePages /DlgSettingsCacheDirectory.cpp

Upload folder using huggingface_hub

985c397 verified 9 months ago

12.9 kB

/***************************************************************************
 *   Copyright (c) 2021 Werner Mayer <wmayer[at]users.sourceforge.net>     *
 *                                                                         *
 *   This file is part of the FreeCAD CAx development system.              *
 *                                                                         *
 *   This library is free software; you can redistribute it and/or         *
 *   modify it under the terms of the GNU Library General Public           *
 *   License as published by the Free Software Foundation; either          *
 *   version 2 of the License, or (at your option) any later version.      *
 *                                                                         *
 *   This library  is distributed in the hope that it will be useful,      *
 *   but WITHOUT ANY WARRANTY; without even the implied warranty of        *
 *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the         *
 *   GNU Library General Public License for more details.                  *
 *                                                                         *
 *   You should have received a copy of the GNU Library General Public     *
 *   License along with this library; see the file COPYING.LIB. If not,    *
 *   write to the Free Software Foundation, Inc., 59 Temple Place,         *
 *   Suite 330, Boston, MA  02111-1307, USA                                *
 *                                                                         *
 ***************************************************************************/

#include <cmath>
#include <limits>
#include <vector>
#include <QCoreApplication>
#include <QDate>
#include <QDesktopServices>
#include <QDir>
#include <QLocale>
#include <QMessageBox>
#include <QSettings>
#include <QUrl>

#include <App/Application.h>
#include <App/Document.h>
#include <Gui/DocumentRecovery.h>
#include <Gui/MainWindow.h>

#include "DlgSettingsCacheDirectory.h"
#include "ui_DlgSettingsCacheDirectory.h"


using namespace Gui::Dialog;

/* TRANSLATOR Gui::Dialog::DlgSettingsCacheDirectory */

QString DlgSettingsCacheDirectory::currentSize;

DlgSettingsCacheDirectory::DlgSettingsCacheDirectory(QWidget* parent)
    : PreferencePage(parent)
    , ui(new Ui_DlgSettingsCacheDirectory)
{
    ui->setupUi(this);
    ui->labelCache->setToolTip(tr("Notify the user if the cache size exceeds the specified limit"));
    if (currentSize.isEmpty()) {
        currentSize = tr("Unknown");
    }
    setCurrentCacheSize(currentSize);

    QString path = QString::fromStdString(App::Application::getUserCachePath());
    ui->cacheLocation->setText(path);

    ui->comboBoxLimit->addItem(QStringLiteral("100 MB"), 100);
    ui->comboBoxLimit->addItem(QStringLiteral("300 MB"), 300);
    ui->comboBoxLimit->addItem(QStringLiteral("500 MB"), 500);
    ui->comboBoxLimit->addItem(QStringLiteral("1 GB"), 1024);
    ui->comboBoxLimit->addItem(QStringLiteral("2 GB"), 2048);
    ui->comboBoxLimit->addItem(QStringLiteral("3 GB"), 3072);

    connect(ui->pushButtonCheck, &QPushButton::clicked, this, &DlgSettingsCacheDirectory::runCheck);
    connect(ui->openButton, &QPushButton::clicked, this, &DlgSettingsCacheDirectory::openDirectory);
}

DlgSettingsCacheDirectory::~DlgSettingsCacheDirectory() = default;

void DlgSettingsCacheDirectory::saveSettings()
{
    ApplicationCacheSettings::setCheckPeriod(ui->comboBoxPeriod->currentIndex());
    ApplicationCacheSettings::setCacheSizeLimit(ui->comboBoxLimit->currentData().toUInt());
}

void DlgSettingsCacheDirectory::loadSettings()
{
    int period = ApplicationCacheSettings::getCheckPeriod();
    if (period >= 0 && period < ui->comboBoxPeriod->count()) {
        ui->comboBoxPeriod->setCurrentIndex(period);
    }
    unsigned int limit = ApplicationCacheSettings::getCacheSizeLimit();
    int index = ui->comboBoxLimit->findData(limit);

    // if not found then add a new item with this value
    if (index < 0) {
        ui->comboBoxLimit->addItem(QStringLiteral("%1 MB").arg(limit), limit);
        index = ui->comboBoxLimit->count() - 1;
    }
    ui->comboBoxLimit->setCurrentIndex(index);
}

void DlgSettingsCacheDirectory::resetSettingsToDefaults()
{
    ParameterGrp::handle hGrp;
    hGrp = WindowParameter::getDefaultParameter()->GetGroup("CacheDirectory");
    // reset "Limit" parameter
    hGrp->RemoveUnsigned("Limit");
    // reset "Period" parameter
    hGrp->RemoveInt("Period");

    // finally reset all the parameters associated to Gui::Pref* widgets
    PreferencePage::resetSettingsToDefaults();
}

void DlgSettingsCacheDirectory::changeEvent(QEvent* e)
{
    if (e->type() == QEvent::LanguageChange) {
        int period = ui->comboBoxPeriod->currentIndex();
        ui->retranslateUi(this);
        ui->comboBoxPeriod->setCurrentIndex(period);
        setCurrentCacheSize(currentSize);
    }
    QWidget::changeEvent(e);
}

void DlgSettingsCacheDirectory::setCurrentCacheSize(const QString& str)
{
    currentSize = str;
    ui->labelCurrentCache->setText(tr("Current cache size: %1").arg(str));
}

void DlgSettingsCacheDirectory::runCheck()
{
    Gui::Dialog::ApplicationCache cache;
    unsigned int sizeInMB = ui->comboBoxLimit->currentData().toUInt();
    cache.setLimit(ApplicationCache::toBytes(sizeInMB));
    qint64 total = cache.size();
    setCurrentCacheSize(ApplicationCache::toString(total));

    // When performing the clean-up then recompute the new cache size
    if (cache.performAction(total)) {
        total = cache.size();
        setCurrentCacheSize(ApplicationCache::toString(total));
    }
}

void DlgSettingsCacheDirectory::openDirectory()
{
    QString path = QString::fromStdString(App::Application::getUserCachePath());
    QUrl url = QUrl::fromLocalFile(path);
    QDesktopServices::openUrl(url);
}

// ----------------------------------------------------------------------------

ApplicationCache::ApplicationCache()
{
    limit = std::pow(1024, 3);
    setPeriod(Period::Weekly);
}

/*!
 * \brief ApplicationCache::setPeriod
 * Set the period to check for the cache size
 * \param period
 */
void ApplicationCache::setPeriod(ApplicationCache::Period period)
{
    switch (period) {
        case Period::Always:
            numDays = -1;
            break;
        case Period::Daily:
            numDays = 1;
            break;
        case Period::Weekly:
            numDays = 7;
            break;
        case Period::Monthly:
            numDays = 31;
            break;
        case Period::Yearly:
            numDays = 365;
            break;
        case Period::Never:
            numDays = std::numeric_limits<int>::max();
            break;
    }
}

/*!
 * \brief ApplicationCache::setLimit
 * Set the limit in bytes to perform a check
 * \param value
 */
void ApplicationCache::setLimit(qint64 value)
{
    limit = value;
}

/*!
 * \brief ApplicationCache::periodicCheckOfSize
 * Checks if the periodic check should be performed now
 * \return
 */
bool ApplicationCache::periodicCheckOfSize() const
{
    QString vendor = QString::fromLatin1(App::Application::Config()["ExeVendor"].c_str());
    QString application = QString::fromStdString(App::Application::getExecutableName());

    QSettings settings(vendor, application);
    QString key = QStringLiteral("LastCacheCheck");
    QDate date = settings.value(key).toDate();
    QDate now = QDate::currentDate();

    // get the days since the last check
    int days = date.daysTo(now);
    if (date.isNull()) {
        days = 1000;
    }

    if (days >= numDays) {
        settings.setValue(key, now);
        return true;
    }

    return false;
}

/*!
 * \brief ApplicationCache::performAction
 * If the cache size \a total is higher than the limit then show a dialog to the user
 * \param total
 */
bool ApplicationCache::performAction(qint64 total)
{
    bool performed = false;
    if (total > limit) {
        QString path = QString::fromStdString(App::Application::getUserCachePath());
        QMessageBox msgBox(Gui::getMainWindow());
        msgBox.setIcon(QMessageBox::Warning);
        msgBox.setWindowTitle(tr("Cache Directory"));

        QString hint = tr("The cache directory %1 exceeds the size of %2.")
                           .arg(path, ApplicationCache::toString(limit));
        QString ask = tr("Clear it now?");
        QString warn = tr("Warning: Make sure that this is the only running %1 instance "
                          "and that no documents are opened as this may result into data loss!")
                           .arg(QCoreApplication::applicationName());

        msgBox.setText(QStringLiteral("%1 %2\n\n\n%3").arg(hint, ask, warn));
        msgBox.setStandardButtons(QMessageBox::Yes | QMessageBox::No | QMessageBox::Open);
        msgBox.setDefaultButton(QMessageBox::No);

        while (true) {
            int ret = msgBox.exec();
            if (ret == QMessageBox::Open) {
                QUrl url = QUrl::fromLocalFile(path);
                QDesktopServices::openUrl(url);
            }
            else {
                if (ret == QMessageBox::Yes) {
                    clearDirectory(path);
                    performed = true;
                }
                break;
            }
        }
    }

    return performed;
}

/*!
 * \brief ApplicationCache::size
 * Determines the size of the cache.
 * \return
 */
qint64 ApplicationCache::size() const
{
    qint64 total = dirSize(QString::fromStdString(App::Application::getUserCachePath()));
    return total;
}

/*!
 * \internal
 */
void ApplicationCache::clearDirectory(const QString& path)
{
    // Add the transient directories and the lock files to the ignore list
    QDir tmp = QString::fromUtf8(App::Application::getUserCachePath().c_str());
    tmp.setNameFilters(QStringList() << QStringLiteral("*.lock"));
    tmp.setFilter(QDir::Files);

    QList<QFileInfo> dirs;
    std::vector<App::Document*> docs = App::GetApplication().getDocuments();
    for (auto it : docs) {
        QDir dir(QString::fromStdString(it->TransientDir.getStrValue()));
        QFileInfo fi(dir.absolutePath());
        dirs.append(fi);
    }

    DocumentRecoveryCleaner cleaner;
    cleaner.setIgnoreFiles(tmp.entryList());
    cleaner.setIgnoreDirectories(dirs);
    cleaner.clearDirectory(QFileInfo(path));
}

/*!
 * \internal
 */
qint64 ApplicationCache::dirSize(QString dirPath) const
{
    qint64 total = 0;
    QDir dir(dirPath);

    QDir::Filters fileFilters = QDir::Files;
    const auto& files = dir.entryList(fileFilters);
    for (const QString& filePath : files) {
        QFileInfo fi(dir, filePath);
        total += fi.size();
    }

    // traverse sub-directories recursively
    QDir::Filters dirFilters = QDir::Dirs | QDir::NoDotAndDotDot;
    const auto& dirs = dir.entryList(dirFilters);
    for (const QString& subDirPath : dirs) {
        total += dirSize(dirPath + QDir::separator() + subDirPath);
    }
    return total;
}

/*!
 * \brief ApplicationCache::applyUserSettings
 * Set period and limit according to user settings
 */
void ApplicationCache::applyUserSettings()
{
    int period = ApplicationCacheSettings::getCheckPeriod();
    setPeriod(static_cast<Period>(period));

    unsigned int sizeInMB = ApplicationCacheSettings::getCacheSizeLimit();
    setLimit(ApplicationCache::toBytes(sizeInMB));
}

qint64 ApplicationCache::toBytes(unsigned int sizeInMB)
{
    qint64 value = static_cast<qint64>(sizeInMB) * 1024 * 1024;
    return value;
}

QString ApplicationCache::toString(qint64 size)
{
    QStringList units
        = {QStringLiteral("Bytes"), QStringLiteral("KB"), QStringLiteral("MB"), QStringLiteral("GB")};
    int i;
    double outputSize = size;
    for (i = 0; i < units.size() - 1; i++) {
        if (outputSize < 1024) {
            break;
        }
        outputSize /= 1024;
    }

    return QStringLiteral("%1 %2").arg(QLocale().toString(outputSize, 'f', 2), units[i]);
}

// ----------------------------------------------------------------------------

unsigned int ApplicationCacheSettings::getCacheSizeLimit()
{
    ParameterGrp::handle hGrp = WindowParameter::getDefaultParameter()->GetGroup("CacheDirectory");
    return hGrp->GetUnsigned("Limit", 500);
}

void ApplicationCacheSettings::setCacheSizeLimit(unsigned int limit)
{
    ParameterGrp::handle hGrp = WindowParameter::getDefaultParameter()->GetGroup("CacheDirectory");
    hGrp->SetUnsigned("Limit", limit);
}

int ApplicationCacheSettings::getCheckPeriod()
{
    ParameterGrp::handle hGrp = WindowParameter::getDefaultParameter()->GetGroup("CacheDirectory");
    return hGrp->GetInt("Period", static_cast<int>(ApplicationCache::Period::Weekly));
}

void ApplicationCacheSettings::setCheckPeriod(int period)
{
    ParameterGrp::handle hGrp = WindowParameter::getDefaultParameter()->GetGroup("CacheDirectory");
    hGrp->SetInt("Period", period);
}


#include "moc_DlgSettingsCacheDirectory.cpp"

	/***************************************************************************
	* Copyright (c) 2021 Werner Mayer <wmayer[at]users.sourceforge.net> *
	* *
	* This file is part of the FreeCAD CAx development system. *
	* *
	* This library is free software; you can redistribute it and/or *
	* modify it under the terms of the GNU Library General Public *
	* License as published by the Free Software Foundation; either *
	* version 2 of the License, or (at your option) any later version. *
	* *
	* This library is distributed in the hope that it will be useful, *
	* but WITHOUT ANY WARRANTY; without even the implied warranty of *
	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *
	* GNU Library General Public License for more details. *
	* *
	* You should have received a copy of the GNU Library General Public *
	* License along with this library; see the file COPYING.LIB. If not, *
	* write to the Free Software Foundation, Inc., 59 Temple Place, *
	* Suite 330, Boston, MA 02111-1307, USA *
	* *
	***************************************************************************/

	#include <cmath>
	#include <limits>
	#include <vector>
	#include <QCoreApplication>
	#include <QDate>
	#include <QDesktopServices>
	#include <QDir>
	#include <QLocale>
	#include <QMessageBox>
	#include <QSettings>
	#include <QUrl>

	#include <App/Application.h>
	#include <App/Document.h>
	#include <Gui/DocumentRecovery.h>
	#include <Gui/MainWindow.h>

	#include "DlgSettingsCacheDirectory.h"
	#include "ui_DlgSettingsCacheDirectory.h"


	using namespace Gui::Dialog;

	/* TRANSLATOR Gui::Dialog::DlgSettingsCacheDirectory */

	QString DlgSettingsCacheDirectory::currentSize;

	DlgSettingsCacheDirectory::DlgSettingsCacheDirectory(QWidget* parent)
	: PreferencePage(parent)
	, ui(new Ui_DlgSettingsCacheDirectory)
	{
	ui->setupUi(this);
	ui->labelCache->setToolTip(tr("Notify the user if the cache size exceeds the specified limit"));
	if (currentSize.isEmpty()) {
	currentSize = tr("Unknown");
	}
	setCurrentCacheSize(currentSize);

	QString path = QString::fromStdString(App::Application::getUserCachePath());
	ui->cacheLocation->setText(path);

	ui->comboBoxLimit->addItem(QStringLiteral("100 MB"), 100);
	ui->comboBoxLimit->addItem(QStringLiteral("300 MB"), 300);
	ui->comboBoxLimit->addItem(QStringLiteral("500 MB"), 500);
	ui->comboBoxLimit->addItem(QStringLiteral("1 GB"), 1024);
	ui->comboBoxLimit->addItem(QStringLiteral("2 GB"), 2048);
	ui->comboBoxLimit->addItem(QStringLiteral("3 GB"), 3072);

	connect(ui->pushButtonCheck, &QPushButton::clicked, this, &DlgSettingsCacheDirectory::runCheck);
	connect(ui->openButton, &QPushButton::clicked, this, &DlgSettingsCacheDirectory::openDirectory);
	}

	DlgSettingsCacheDirectory::~DlgSettingsCacheDirectory() = default;

	void DlgSettingsCacheDirectory::saveSettings()
	{
	ApplicationCacheSettings::setCheckPeriod(ui->comboBoxPeriod->currentIndex());
	ApplicationCacheSettings::setCacheSizeLimit(ui->comboBoxLimit->currentData().toUInt());
	}

	void DlgSettingsCacheDirectory::loadSettings()
	{
	int period = ApplicationCacheSettings::getCheckPeriod();
	if (period >= 0 && period < ui->comboBoxPeriod->count()) {
	ui->comboBoxPeriod->setCurrentIndex(period);
	}
	unsigned int limit = ApplicationCacheSettings::getCacheSizeLimit();
	int index = ui->comboBoxLimit->findData(limit);

	// if not found then add a new item with this value
	if (index < 0) {
	ui->comboBoxLimit->addItem(QStringLiteral("%1 MB").arg(limit), limit);
	index = ui->comboBoxLimit->count() - 1;
	}
	ui->comboBoxLimit->setCurrentIndex(index);
	}

	void DlgSettingsCacheDirectory::resetSettingsToDefaults()
	{
	ParameterGrp::handle hGrp;
	hGrp = WindowParameter::getDefaultParameter()->GetGroup("CacheDirectory");
	// reset "Limit" parameter
	hGrp->RemoveUnsigned("Limit");
	// reset "Period" parameter
	hGrp->RemoveInt("Period");

	// finally reset all the parameters associated to Gui::Pref* widgets
	PreferencePage::resetSettingsToDefaults();
	}

	void DlgSettingsCacheDirectory::changeEvent(QEvent* e)
	{
	if (e->type() == QEvent::LanguageChange) {
	int period = ui->comboBoxPeriod->currentIndex();
	ui->retranslateUi(this);
	ui->comboBoxPeriod->setCurrentIndex(period);
	setCurrentCacheSize(currentSize);
	}
	QWidget::changeEvent(e);
	}

	void DlgSettingsCacheDirectory::setCurrentCacheSize(const QString& str)
	{
	currentSize = str;
	ui->labelCurrentCache->setText(tr("Current cache size: %1").arg(str));
	}

	void DlgSettingsCacheDirectory::runCheck()
	{
	Gui::Dialog::ApplicationCache cache;
	unsigned int sizeInMB = ui->comboBoxLimit->currentData().toUInt();
	cache.setLimit(ApplicationCache::toBytes(sizeInMB));
	qint64 total = cache.size();
	setCurrentCacheSize(ApplicationCache::toString(total));

	// When performing the clean-up then recompute the new cache size
	if (cache.performAction(total)) {
	total = cache.size();
	setCurrentCacheSize(ApplicationCache::toString(total));
	}
	}

	void DlgSettingsCacheDirectory::openDirectory()
	{
	QString path = QString::fromStdString(App::Application::getUserCachePath());
	QUrl url = QUrl::fromLocalFile(path);
	QDesktopServices::openUrl(url);
	}

	// ----------------------------------------------------------------------------

	ApplicationCache::ApplicationCache()
	{
	limit = std::pow(1024, 3);
	setPeriod(Period::Weekly);
	}

	/*!
	* \brief ApplicationCache::setPeriod
	* Set the period to check for the cache size
	* \param period
	*/
	void ApplicationCache::setPeriod(ApplicationCache::Period period)
	{
	switch (period) {
	case Period::Always:
	numDays = -1;
	break;
	case Period::Daily:
	numDays = 1;
	break;
	case Period::Weekly:
	numDays = 7;
	break;
	case Period::Monthly:
	numDays = 31;
	break;
	case Period::Yearly:
	numDays = 365;
	break;
	case Period::Never:
	numDays = std::numeric_limits<int>::max();
	break;
	}
	}

	/*!
	* \brief ApplicationCache::setLimit
	* Set the limit in bytes to perform a check
	* \param value
	*/
	void ApplicationCache::setLimit(qint64 value)
	{
	limit = value;
	}

	/*!
	* \brief ApplicationCache::periodicCheckOfSize
	* Checks if the periodic check should be performed now
	* \return
	*/
	bool ApplicationCache::periodicCheckOfSize() const
	{
	QString vendor = QString::fromLatin1(App::Application::Config()["ExeVendor"].c_str());
	QString application = QString::fromStdString(App::Application::getExecutableName());

	QSettings settings(vendor, application);
	QString key = QStringLiteral("LastCacheCheck");
	QDate date = settings.value(key).toDate();
	QDate now = QDate::currentDate();

	// get the days since the last check
	int days = date.daysTo(now);
	if (date.isNull()) {
	days = 1000;
	}

	if (days >= numDays) {
	settings.setValue(key, now);
	return true;
	}

	return false;
	}

	/*!
	* \brief ApplicationCache::performAction
	* If the cache size \a total is higher than the limit then show a dialog to the user
	* \param total
	*/
	bool ApplicationCache::performAction(qint64 total)
	{
	bool performed = false;
	if (total > limit) {
	QString path = QString::fromStdString(App::Application::getUserCachePath());
	QMessageBox msgBox(Gui::getMainWindow());
	msgBox.setIcon(QMessageBox::Warning);
	msgBox.setWindowTitle(tr("Cache Directory"));

	QString hint = tr("The cache directory %1 exceeds the size of %2.")
	.arg(path, ApplicationCache::toString(limit));
	QString ask = tr("Clear it now?");
	QString warn = tr("Warning: Make sure that this is the only running %1 instance "
	"and that no documents are opened as this may result into data loss!")
	.arg(QCoreApplication::applicationName());

	msgBox.setText(QStringLiteral("%1 %2\n\n\n%3").arg(hint, ask, warn));
	msgBox.setStandardButtons(QMessageBox::Yes \| QMessageBox::No \| QMessageBox::Open);
	msgBox.setDefaultButton(QMessageBox::No);

	while (true) {
	int ret = msgBox.exec();
	if (ret == QMessageBox::Open) {
	QUrl url = QUrl::fromLocalFile(path);
	QDesktopServices::openUrl(url);
	}
	else {
	if (ret == QMessageBox::Yes) {
	clearDirectory(path);
	performed = true;
	}
	break;
	}
	}
	}

	return performed;
	}

	/*!
	* \brief ApplicationCache::size
	* Determines the size of the cache.
	* \return
	*/
	qint64 ApplicationCache::size() const
	{
	qint64 total = dirSize(QString::fromStdString(App::Application::getUserCachePath()));
	return total;
	}

	/*!
	* \internal
	*/
	void ApplicationCache::clearDirectory(const QString& path)
	{
	// Add the transient directories and the lock files to the ignore list
	QDir tmp = QString::fromUtf8(App::Application::getUserCachePath().c_str());
	tmp.setNameFilters(QStringList() << QStringLiteral("*.lock"));
	tmp.setFilter(QDir::Files);

	QList<QFileInfo> dirs;
	std::vector<App::Document*> docs = App::GetApplication().getDocuments();
	for (auto it : docs) {
	QDir dir(QString::fromStdString(it->TransientDir.getStrValue()));
	QFileInfo fi(dir.absolutePath());
	dirs.append(fi);
	}

	DocumentRecoveryCleaner cleaner;
	cleaner.setIgnoreFiles(tmp.entryList());
	cleaner.setIgnoreDirectories(dirs);
	cleaner.clearDirectory(QFileInfo(path));
	}

	/*!
	* \internal
	*/
	qint64 ApplicationCache::dirSize(QString dirPath) const
	{
	qint64 total = 0;
	QDir dir(dirPath);

	QDir::Filters fileFilters = QDir::Files;
	const auto& files = dir.entryList(fileFilters);
	for (const QString& filePath : files) {
	QFileInfo fi(dir, filePath);
	total += fi.size();
	}

	// traverse sub-directories recursively
	QDir::Filters dirFilters = QDir::Dirs \| QDir::NoDotAndDotDot;
	const auto& dirs = dir.entryList(dirFilters);
	for (const QString& subDirPath : dirs) {
	total += dirSize(dirPath + QDir::separator() + subDirPath);
	}
	return total;
	}

	/*!
	* \brief ApplicationCache::applyUserSettings
	* Set period and limit according to user settings
	*/
	void ApplicationCache::applyUserSettings()
	{
	int period = ApplicationCacheSettings::getCheckPeriod();
	setPeriod(static_cast<Period>(period));

	unsigned int sizeInMB = ApplicationCacheSettings::getCacheSizeLimit();
	setLimit(ApplicationCache::toBytes(sizeInMB));
	}

	qint64 ApplicationCache::toBytes(unsigned int sizeInMB)
	{
	qint64 value = static_cast<qint64>(sizeInMB) * 1024 * 1024;
	return value;
	}

	QString ApplicationCache::toString(qint64 size)
	{
	QStringList units
	= {QStringLiteral("Bytes"), QStringLiteral("KB"), QStringLiteral("MB"), QStringLiteral("GB")};
	int i;
	double outputSize = size;
	for (i = 0; i < units.size() - 1; i++) {
	if (outputSize < 1024) {
	break;
	}
	outputSize /= 1024;
	}

	return QStringLiteral("%1 %2").arg(QLocale().toString(outputSize, 'f', 2), units[i]);
	}

	// ----------------------------------------------------------------------------

	unsigned int ApplicationCacheSettings::getCacheSizeLimit()
	{
	ParameterGrp::handle hGrp = WindowParameter::getDefaultParameter()->GetGroup("CacheDirectory");
	return hGrp->GetUnsigned("Limit", 500);
	}

	void ApplicationCacheSettings::setCacheSizeLimit(unsigned int limit)
	{
	ParameterGrp::handle hGrp = WindowParameter::getDefaultParameter()->GetGroup("CacheDirectory");
	hGrp->SetUnsigned("Limit", limit);
	}

	int ApplicationCacheSettings::getCheckPeriod()
	{
	ParameterGrp::handle hGrp = WindowParameter::getDefaultParameter()->GetGroup("CacheDirectory");
	return hGrp->GetInt("Period", static_cast<int>(ApplicationCache::Period::Weekly));
	}

	void ApplicationCacheSettings::setCheckPeriod(int period)
	{
	ParameterGrp::handle hGrp = WindowParameter::getDefaultParameter()->GetGroup("CacheDirectory");
	hGrp->SetInt("Period", period);
	}


	#include "moc_DlgSettingsCacheDirectory.cpp"