/**************************************************************************
**                                                                      **
** Copyright (C) 2011-2026 Lukas Spies                                  **
** Contact: https://photoqt.org                                         **
**                                                                      **
** This file is part of PhotoQt.                                        **
**                                                                      **
** PhotoQt is free software: you can redistribute it and/or modify      **
** it under the terms of the GNU General Public License as published by **
** the Free Software Foundation, either version 2 of the License, or    **
** (at your option) any later version.                                  **
**                                                                      **
** PhotoQt 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 General Public License for more details.                         **
**                                                                      **
** You should have received a copy of the GNU General Public License    **
** along with PhotoQt. If not, see <http://www.gnu.org/licenses/>.      **
**                                                                      **
**************************************************************************/

/**//**//**//**//**//**//**//**//**//**//**//**//**//**//**/
//
// WARNING
// THIS FILE IS AUTO GENERATED BY `misc/pqc_settings.py`.
// ANY CHANGES HERE WILL BE OVERWRITTEN AT SOME POINT!
//
/**//**//**//**//**//**//**//**//**//**//**//**//**//**//**/

#include <QJSValue>
#include <QMessageBox>
#include <qlogging.h>   // needed in this form to compile with Qt 6.2
#include <QApplication>
#include <QtSql/QSqlError>
#include <QtSql/QSqlQuery>
#include <pqc_settings.h>
#include <pqc_settingscpp.h>
#include <pqc_configfiles.h>
#include <pqc_notify_cpp.h>
#include <pqc_extensionshandler.h>

PQCSettings::PQCSettings(bool validateonly) {
    if(validateonly) {
        dbCommitTimer = nullptr;
        qDebug() << "THIS INSTANCE SHOULD ONLY BE USED FOR VALIDATING!";
    } else
        PQCSettings();
}

PQCSettings::PQCSettings() {

    QSqlDatabase dbDefault;

    // create and connect to default database
    if(QSqlDatabase::contains("defaultsettings"))
        dbDefault = QSqlDatabase::database("defaultsettings");
    else {
        if(QSqlDatabase::isDriverAvailable("QSQLITE3"))
            dbDefault = QSqlDatabase::addDatabase("QSQLITE3", "defaultsettings");
        else if(QSqlDatabase::isDriverAvailable("QSQLITE"))
            dbDefault = QSqlDatabase::addDatabase("QSQLITE", "defaultsettings");
    }
    QFile::remove(PQCConfigFiles::get().DEFAULTSETTINGS_DB());
    QFile::copy(":/defaultsettings.db", PQCConfigFiles::get().DEFAULTSETTINGS_DB());
    dbDefault.setDatabaseName(PQCConfigFiles::get().DEFAULTSETTINGS_DB());
    if(!dbDefault.open()) {
        qCritical() << "ERROR opening default database:" << (PQCConfigFiles::get().DEFAULTSETTINGS_DB());
        QMessageBox::critical(0, QApplication::translate("PQSettings", "ERROR opening database with default settings"),
                            QApplication::translate("PQSettings", "I tried hard, but I just cannot open the database of default settings.") + QApplication::translate("PQSettings", "Something went terribly wrong somewhere!"));
        return;
    }

    QSqlDatabase db = QSqlDatabase::database("settings");

    dbtables = QStringList() << "general"
                            << "interface"
                            << "imageview"
                            << "thumbnails"
                            << "mainmenu"
                            << "metadata"
                            << "filetypes"
                            << "filedialog"
                            << "slideshow"
                            << "mapview";

    readonly = false;

    if(!db.open()) {

        qWarning() << "ERROR opening database:" << db.lastError().text();
        qWarning() << "Will load read-only set of default settings";

        readonly = true;

    } else {

        QFileInfo infodb(PQCConfigFiles::get().USERSETTINGS_DB());

        readonly = false;
        if(!infodb.permission(QFileDevice::WriteOwner))
            readonly = true;

    }

    dbIsTransaction = false;
    dbCommitTimer = new QTimer();
    dbCommitTimer->setSingleShot(true);
    dbCommitTimer->setInterval(400);
    connect(dbCommitTimer, &QTimer::timeout, this, [this]() {
        QSqlDatabase db = QSqlDatabase::database("settings");
        db.commit();
        PQCSettingsCPP::get().readDB();
        dbIsTransaction = false;
        if(db.lastError().text().trimmed().length())
            qWarning() << "ERROR committing database:" << db.lastError().text();
    });

    /******************************************************/

    // set up with all defaults
    setupFresh();

    /******************************************************/

    // then update with user settings (if applicable)
    QFileInfo info(PQCConfigFiles::get().USERSETTINGS_DB());
    if(!info.exists()) {
        if(!QFile::copy(":/usersettings.db", PQCConfigFiles::get().USERSETTINGS_DB()))
            qWarning() << "Unable to (re-)create default settings database";
        else {
            QFile file(PQCConfigFiles::get().USERSETTINGS_DB());
            file.setPermissions(file.permissions()|QFileDevice::WriteOwner);
        }
    } else
        readDB();

    /******************************************************/
    
    // table: filedialog
    connect(this, &PQCSettings::filedialogDetailsTooltipChanged, this, [this]() { saveChangedValue("filedialogDetailsTooltip", m_filedialogDetailsTooltip); });
    connect(this, &PQCSettings::filedialogDevicesChanged, this, [this]() { saveChangedValue("filedialogDevices", m_filedialogDevices); });
    connect(this, &PQCSettings::filedialogDevicesShowTmpfsChanged, this, [this]() { saveChangedValue("filedialogDevicesShowTmpfs", m_filedialogDevicesShowTmpfs); });
    connect(this, &PQCSettings::filedialogDragDropFileviewGridChanged, this, [this]() { saveChangedValue("filedialogDragDropFileviewGrid", m_filedialogDragDropFileviewGrid); });
    connect(this, &PQCSettings::filedialogDragDropFileviewListChanged, this, [this]() { saveChangedValue("filedialogDragDropFileviewList", m_filedialogDragDropFileviewList); });
    connect(this, &PQCSettings::filedialogDragDropFileviewMasonryChanged, this, [this]() { saveChangedValue("filedialogDragDropFileviewMasonry", m_filedialogDragDropFileviewMasonry); });
    connect(this, &PQCSettings::filedialogDragDropPlacesChanged, this, [this]() { saveChangedValue("filedialogDragDropPlaces", m_filedialogDragDropPlaces); });
    connect(this, &PQCSettings::filedialogElementPaddingChanged, this, [this]() { saveChangedValue("filedialogElementPadding", m_filedialogElementPadding); });
    connect(this, &PQCSettings::filedialogFolderContentThumbnailsChanged, this, [this]() { saveChangedValue("filedialogFolderContentThumbnails", m_filedialogFolderContentThumbnails); });
    connect(this, &PQCSettings::filedialogFolderContentThumbnailsAutoloadChanged, this, [this]() { saveChangedValue("filedialogFolderContentThumbnailsAutoload", m_filedialogFolderContentThumbnailsAutoload); });
    connect(this, &PQCSettings::filedialogFolderContentThumbnailsLoopChanged, this, [this]() { saveChangedValue("filedialogFolderContentThumbnailsLoop", m_filedialogFolderContentThumbnailsLoop); });
    connect(this, &PQCSettings::filedialogFolderContentThumbnailsScaleCropChanged, this, [this]() { saveChangedValue("filedialogFolderContentThumbnailsScaleCrop", m_filedialogFolderContentThumbnailsScaleCrop); });
    connect(this, &PQCSettings::filedialogFolderContentThumbnailsSortAscendingChanged, this, [this]() { saveChangedValue("filedialogFolderContentThumbnailsSortAscending", m_filedialogFolderContentThumbnailsSortAscending); });
    connect(this, &PQCSettings::filedialogFolderContentThumbnailsSortByChanged, this, [this]() { saveChangedValue("filedialogFolderContentThumbnailsSortBy", m_filedialogFolderContentThumbnailsSortBy); });
    connect(this, &PQCSettings::filedialogFolderContentThumbnailsSpeedChanged, this, [this]() { saveChangedValue("filedialogFolderContentThumbnailsSpeed", m_filedialogFolderContentThumbnailsSpeed); });
    connect(this, &PQCSettings::filedialogLabelsShowGridChanged, this, [this]() { saveChangedValue("filedialogLabelsShowGrid", m_filedialogLabelsShowGrid); });
    connect(this, &PQCSettings::filedialogLabelsShowMasonryChanged, this, [this]() { saveChangedValue("filedialogLabelsShowMasonry", m_filedialogLabelsShowMasonry); });
    connect(this, &PQCSettings::filedialogLayoutChanged, this, [this]() { saveChangedValue("filedialogLayout", m_filedialogLayout); });
    connect(this, &PQCSettings::filedialogPlacesChanged, this, [this]() { saveChangedValue("filedialogPlaces", m_filedialogPlaces); });
    connect(this, &PQCSettings::filedialogPlacesWidthChanged, this, [this]() { saveChangedValue("filedialogPlacesWidth", m_filedialogPlacesWidth); });
    connect(this, &PQCSettings::filedialogPreviewChanged, this, [this]() { saveChangedValue("filedialogPreview", m_filedialogPreview); });
    connect(this, &PQCSettings::filedialogPreviewBlurChanged, this, [this]() { saveChangedValue("filedialogPreviewBlur", m_filedialogPreviewBlur); });
    connect(this, &PQCSettings::filedialogPreviewColorIntensityChanged, this, [this]() { saveChangedValue("filedialogPreviewColorIntensity", m_filedialogPreviewColorIntensity); });
    connect(this, &PQCSettings::filedialogPreviewCropToFitChanged, this, [this]() { saveChangedValue("filedialogPreviewCropToFit", m_filedialogPreviewCropToFit); });
    connect(this, &PQCSettings::filedialogPreviewHigherResolutionChanged, this, [this]() { saveChangedValue("filedialogPreviewHigherResolution", m_filedialogPreviewHigherResolution); });
    connect(this, &PQCSettings::filedialogPreviewMutedChanged, this, [this]() { saveChangedValue("filedialogPreviewMuted", m_filedialogPreviewMuted); });
    connect(this, &PQCSettings::filedialogRememberSelectionChanged, this, [this]() { saveChangedValue("filedialogRememberSelection", m_filedialogRememberSelection); });
    connect(this, &PQCSettings::filedialogShowHiddenFilesFoldersChanged, this, [this]() { saveChangedValue("filedialogShowHiddenFilesFolders", m_filedialogShowHiddenFilesFolders); });
    connect(this, &PQCSettings::filedialogSingleClickSelectChanged, this, [this]() { saveChangedValue("filedialogSingleClickSelect", m_filedialogSingleClickSelect); });
    connect(this, &PQCSettings::filedialogStartupRestoreCustomChanged, this, [this]() { saveChangedValue("filedialogStartupRestoreCustom", m_filedialogStartupRestoreCustom); });
    connect(this, &PQCSettings::filedialogStartupRestoreCustomFolderChanged, this, [this]() { saveChangedValue("filedialogStartupRestoreCustomFolder", m_filedialogStartupRestoreCustomFolder); });
    connect(this, &PQCSettings::filedialogStartupRestoreHomeChanged, this, [this]() { saveChangedValue("filedialogStartupRestoreHome", m_filedialogStartupRestoreHome); });
    connect(this, &PQCSettings::filedialogStartupRestorePreviousChanged, this, [this]() { saveChangedValue("filedialogStartupRestorePrevious", m_filedialogStartupRestorePrevious); });
    connect(this, &PQCSettings::filedialogThumbnailSizeFollowsGlobalThumbnailsChanged, this, [this]() { saveChangedValue("filedialogThumbnailSizeFollowsGlobalThumbnails", m_filedialogThumbnailSizeFollowsGlobalThumbnails); });
    connect(this, &PQCSettings::filedialogThumbnailsChanged, this, [this]() { saveChangedValue("filedialogThumbnails", m_filedialogThumbnails); });
    connect(this, &PQCSettings::filedialogThumbnailsScaleCropChanged, this, [this]() { saveChangedValue("filedialogThumbnailsScaleCrop", m_filedialogThumbnailsScaleCrop); });
    connect(this, &PQCSettings::filedialogUseNativeFileDialogChanged, this, [this]() { saveChangedValue("filedialogUseNativeFileDialog", m_filedialogUseNativeFileDialog); });
    connect(this, &PQCSettings::filedialogZoomChanged, this, [this]() { saveChangedValue("filedialogZoom", m_filedialogZoom); });
    // table: filetypes
    connect(this, &PQCSettings::filetypesAnimatedControlsChanged, this, [this]() { saveChangedValue("filetypesAnimatedControls", m_filetypesAnimatedControls); });
    connect(this, &PQCSettings::filetypesAnimatedLeftRightChanged, this, [this]() { saveChangedValue("filetypesAnimatedLeftRight", m_filetypesAnimatedLeftRight); });
    connect(this, &PQCSettings::filetypesAnimatedSpacePauseChanged, this, [this]() { saveChangedValue("filetypesAnimatedSpacePause", m_filetypesAnimatedSpacePause); });
    connect(this, &PQCSettings::filetypesArchiveAlwaysEnterAutomaticallyChanged, this, [this]() { saveChangedValue("filetypesArchiveAlwaysEnterAutomatically", m_filetypesArchiveAlwaysEnterAutomatically); });
    connect(this, &PQCSettings::filetypesArchiveControlsChanged, this, [this]() { saveChangedValue("filetypesArchiveControls", m_filetypesArchiveControls); });
    connect(this, &PQCSettings::filetypesArchiveDontLoadMoreFilesThanChanged, this, [this]() { saveChangedValue("filetypesArchiveDontLoadMoreFilesThan", m_filetypesArchiveDontLoadMoreFilesThan); });
    connect(this, &PQCSettings::filetypesArchiveDontLoadMoreFilesThanCountChanged, this, [this]() { saveChangedValue("filetypesArchiveDontLoadMoreFilesThanCount", m_filetypesArchiveDontLoadMoreFilesThanCount); });
    connect(this, &PQCSettings::filetypesArchiveIgnoreLargerThanChanged, this, [this]() { saveChangedValue("filetypesArchiveIgnoreLargerThan", m_filetypesArchiveIgnoreLargerThan); });
    connect(this, &PQCSettings::filetypesArchiveIgnoreLargerThanSizeChanged, this, [this]() { saveChangedValue("filetypesArchiveIgnoreLargerThanSize", m_filetypesArchiveIgnoreLargerThanSize); });
    connect(this, &PQCSettings::filetypesArchiveLeftRightChanged, this, [this]() { saveChangedValue("filetypesArchiveLeftRight", m_filetypesArchiveLeftRight); });
    connect(this, &PQCSettings::filetypesArchiveViewerModeExitButtonChanged, this, [this]() { saveChangedValue("filetypesArchiveViewerModeExitButton", m_filetypesArchiveViewerModeExitButton); });
    connect(this, &PQCSettings::filetypesComicBookAlwaysEnterAutomaticallyChanged, this, [this]() { saveChangedValue("filetypesComicBookAlwaysEnterAutomatically", m_filetypesComicBookAlwaysEnterAutomatically); });
    connect(this, &PQCSettings::filetypesDocumentAlwaysEnterAutomaticallyChanged, this, [this]() { saveChangedValue("filetypesDocumentAlwaysEnterAutomatically", m_filetypesDocumentAlwaysEnterAutomatically); });
    connect(this, &PQCSettings::filetypesDocumentControlsChanged, this, [this]() { saveChangedValue("filetypesDocumentControls", m_filetypesDocumentControls); });
    connect(this, &PQCSettings::filetypesDocumentLeftRightChanged, this, [this]() { saveChangedValue("filetypesDocumentLeftRight", m_filetypesDocumentLeftRight); });
    connect(this, &PQCSettings::filetypesDocumentViewerModeExitButtonChanged, this, [this]() { saveChangedValue("filetypesDocumentViewerModeExitButton", m_filetypesDocumentViewerModeExitButton); });
    connect(this, &PQCSettings::filetypesExternalUnrarChanged, this, [this]() { saveChangedValue("filetypesExternalUnrar", m_filetypesExternalUnrar); });
    connect(this, &PQCSettings::filetypesLoadAppleLivePhotosChanged, this, [this]() { saveChangedValue("filetypesLoadAppleLivePhotos", m_filetypesLoadAppleLivePhotos); });
    connect(this, &PQCSettings::filetypesLoadMotionPhotosChanged, this, [this]() { saveChangedValue("filetypesLoadMotionPhotos", m_filetypesLoadMotionPhotos); });
    connect(this, &PQCSettings::filetypesMotionAutoPlayChanged, this, [this]() { saveChangedValue("filetypesMotionAutoPlay", m_filetypesMotionAutoPlay); });
    connect(this, &PQCSettings::filetypesMotionPhotoPlayPauseChanged, this, [this]() { saveChangedValue("filetypesMotionPhotoPlayPause", m_filetypesMotionPhotoPlayPause); });
    connect(this, &PQCSettings::filetypesMotionSpacePauseChanged, this, [this]() { saveChangedValue("filetypesMotionSpacePause", m_filetypesMotionSpacePause); });
    connect(this, &PQCSettings::filetypesPDFQualityChanged, this, [this]() { saveChangedValue("filetypesPDFQuality", m_filetypesPDFQuality); });
    connect(this, &PQCSettings::filetypesPhotoSphereArrowKeysChanged, this, [this]() { saveChangedValue("filetypesPhotoSphereArrowKeys", m_filetypesPhotoSphereArrowKeys); });
    connect(this, &PQCSettings::filetypesPhotoSphereAutoLoadChanged, this, [this]() { saveChangedValue("filetypesPhotoSphereAutoLoad", m_filetypesPhotoSphereAutoLoad); });
    connect(this, &PQCSettings::filetypesPhotoSphereBigButtonChanged, this, [this]() { saveChangedValue("filetypesPhotoSphereBigButton", m_filetypesPhotoSphereBigButton); });
    connect(this, &PQCSettings::filetypesPhotoSphereControlsChanged, this, [this]() { saveChangedValue("filetypesPhotoSphereControls", m_filetypesPhotoSphereControls); });
    connect(this, &PQCSettings::filetypesPhotoSpherePanOnLoadChanged, this, [this]() { saveChangedValue("filetypesPhotoSpherePanOnLoad", m_filetypesPhotoSpherePanOnLoad); });
    connect(this, &PQCSettings::filetypesRAWUseEmbeddedIfAvailableChanged, this, [this]() { saveChangedValue("filetypesRAWUseEmbeddedIfAvailable", m_filetypesRAWUseEmbeddedIfAvailable); });
    connect(this, &PQCSettings::filetypesVideoAutoplayChanged, this, [this]() { saveChangedValue("filetypesVideoAutoplay", m_filetypesVideoAutoplay); });
    connect(this, &PQCSettings::filetypesVideoBackendChanged, this, [this]() { saveChangedValue("filetypesVideoBackend", m_filetypesVideoBackend); });
    connect(this, &PQCSettings::filetypesVideoLeftRightJumpVideoChanged, this, [this]() { saveChangedValue("filetypesVideoLeftRightJumpVideo", m_filetypesVideoLeftRightJumpVideo); });
    connect(this, &PQCSettings::filetypesVideoLoopChanged, this, [this]() { saveChangedValue("filetypesVideoLoop", m_filetypesVideoLoop); });
    connect(this, &PQCSettings::filetypesVideoSpacePauseChanged, this, [this]() { saveChangedValue("filetypesVideoSpacePause", m_filetypesVideoSpacePause); });
    connect(this, &PQCSettings::filetypesVideoThumbnailerChanged, this, [this]() { saveChangedValue("filetypesVideoThumbnailer", m_filetypesVideoThumbnailer); });
    connect(this, &PQCSettings::filetypesVideoVolumeChanged, this, [this]() { saveChangedValue("filetypesVideoVolume", m_filetypesVideoVolume); });
    // table: general
    connect(this, &PQCSettings::generalAutoSaveSettingsChanged, this, [this]() { saveChangedValue("generalAutoSaveSettings", m_generalAutoSaveSettings); });
    connect(this, &PQCSettings::generalCompactSettingsChanged, this, [this]() { saveChangedValue("generalCompactSettings", m_generalCompactSettings); });
    connect(this, &PQCSettings::generalDisableAllAnimationsChanged, this, [this]() { saveChangedValue("generalDisableAllAnimations", m_generalDisableAllAnimations); });
    connect(this, &PQCSettings::generalExtensionsAllowUntrustedChanged, this, [this]() { saveChangedValue("generalExtensionsAllowUntrusted", m_generalExtensionsAllowUntrusted); });
    connect(this, &PQCSettings::generalExtensionsEnabledChanged, this, [this]() { saveChangedValue("generalExtensionsEnabled", m_generalExtensionsEnabled); });
    connect(this, &PQCSettings::generalExtensionsFloatingSetupChanged, this, [this]() { saveChangedValue("generalExtensionsFloatingSetup", m_generalExtensionsFloatingSetup); });
    connect(this, &PQCSettings::generalInterfaceVariantChanged, this, [this]() { saveChangedValue("generalInterfaceVariant", m_generalInterfaceVariant); });
    connect(this, &PQCSettings::generalVersionChanged, this, [this]() { saveChangedValue("generalVersion", m_generalVersion); });
    // table: imageview
    connect(this, &PQCSettings::imageviewAdvancedSortAscendingChanged, this, [this]() { saveChangedValue("imageviewAdvancedSortAscending", m_imageviewAdvancedSortAscending); });
    connect(this, &PQCSettings::imageviewAdvancedSortCriteriaChanged, this, [this]() { saveChangedValue("imageviewAdvancedSortCriteria", m_imageviewAdvancedSortCriteria); });
    connect(this, &PQCSettings::imageviewAdvancedSortDateCriteriaChanged, this, [this]() { saveChangedValue("imageviewAdvancedSortDateCriteria", m_imageviewAdvancedSortDateCriteria); });
    connect(this, &PQCSettings::imageviewAdvancedSortQualityChanged, this, [this]() { saveChangedValue("imageviewAdvancedSortQuality", m_imageviewAdvancedSortQuality); });
    connect(this, &PQCSettings::imageviewAlwaysActualSizeChanged, this, [this]() { saveChangedValue("imageviewAlwaysActualSize", m_imageviewAlwaysActualSize); });
    connect(this, &PQCSettings::imageviewAnimationDurationChanged, this, [this]() { saveChangedValue("imageviewAnimationDuration", m_imageviewAnimationDuration); });
    connect(this, &PQCSettings::imageviewAnimationTypeChanged, this, [this]() { saveChangedValue("imageviewAnimationType", m_imageviewAnimationType); });
    connect(this, &PQCSettings::imageviewCacheChanged, this, [this]() { saveChangedValue("imageviewCache", m_imageviewCache); });
    connect(this, &PQCSettings::imageviewColorSpaceContextMenuChanged, this, [this]() { saveChangedValue("imageviewColorSpaceContextMenu", m_imageviewColorSpaceContextMenu); });
    connect(this, &PQCSettings::imageviewColorSpaceDefaultChanged, this, [this]() { saveChangedValue("imageviewColorSpaceDefault", m_imageviewColorSpaceDefault); });
    connect(this, &PQCSettings::imageviewColorSpaceEnableChanged, this, [this]() { saveChangedValue("imageviewColorSpaceEnable", m_imageviewColorSpaceEnable); });
    connect(this, &PQCSettings::imageviewColorSpaceLoadEmbeddedChanged, this, [this]() { saveChangedValue("imageviewColorSpaceLoadEmbedded", m_imageviewColorSpaceLoadEmbedded); });
    connect(this, &PQCSettings::imageviewEscapeExitArchiveChanged, this, [this]() { saveChangedValue("imageviewEscapeExitArchive", m_imageviewEscapeExitArchive); });
    connect(this, &PQCSettings::imageviewEscapeExitBarcodesChanged, this, [this]() { saveChangedValue("imageviewEscapeExitBarcodes", m_imageviewEscapeExitBarcodes); });
    connect(this, &PQCSettings::imageviewEscapeExitDocumentChanged, this, [this]() { saveChangedValue("imageviewEscapeExitDocument", m_imageviewEscapeExitDocument); });
    connect(this, &PQCSettings::imageviewEscapeExitFilterChanged, this, [this]() { saveChangedValue("imageviewEscapeExitFilter", m_imageviewEscapeExitFilter); });
    connect(this, &PQCSettings::imageviewEscapeExitSphereChanged, this, [this]() { saveChangedValue("imageviewEscapeExitSphere", m_imageviewEscapeExitSphere); });
    connect(this, &PQCSettings::imageviewFitInWindowChanged, this, [this]() { saveChangedValue("imageviewFitInWindow", m_imageviewFitInWindow); });
    connect(this, &PQCSettings::imageviewHideCursorTimeoutChanged, this, [this]() { saveChangedValue("imageviewHideCursorTimeout", m_imageviewHideCursorTimeout); });
    connect(this, &PQCSettings::imageviewInterpolationFullImageChanged, this, [this]() { saveChangedValue("imageviewInterpolationFullImage", m_imageviewInterpolationFullImage); });
    connect(this, &PQCSettings::imageviewLoopThroughFolderChanged, this, [this]() { saveChangedValue("imageviewLoopThroughFolder", m_imageviewLoopThroughFolder); });
    connect(this, &PQCSettings::imageviewMarginChanged, this, [this]() { saveChangedValue("imageviewMargin", m_imageviewMargin); });
    connect(this, &PQCSettings::imageviewMinimapSizeLevelChanged, this, [this]() { saveChangedValue("imageviewMinimapSizeLevel", m_imageviewMinimapSizeLevel); });
    connect(this, &PQCSettings::imageviewMirrorAnimateChanged, this, [this]() { saveChangedValue("imageviewMirrorAnimate", m_imageviewMirrorAnimate); });
    connect(this, &PQCSettings::imageviewMouseWheelRepeatDelayChanged, this, [this]() { saveChangedValue("imageviewMouseWheelRepeatDelay", m_imageviewMouseWheelRepeatDelay); });
    connect(this, &PQCSettings::imageviewPreloadInBackgroundChanged, this, [this]() { saveChangedValue("imageviewPreloadInBackground", m_imageviewPreloadInBackground); });
    connect(this, &PQCSettings::imageviewPreserveMirrorChanged, this, [this]() { saveChangedValue("imageviewPreserveMirror", m_imageviewPreserveMirror); });
    connect(this, &PQCSettings::imageviewPreserveRotationChanged, this, [this]() { saveChangedValue("imageviewPreserveRotation", m_imageviewPreserveRotation); });
    connect(this, &PQCSettings::imageviewPreserveZoomChanged, this, [this]() { saveChangedValue("imageviewPreserveZoom", m_imageviewPreserveZoom); });
    connect(this, &PQCSettings::imageviewRememberZoomRotationMirrorChanged, this, [this]() { saveChangedValue("imageviewRememberZoomRotationMirror", m_imageviewRememberZoomRotationMirror); });
    connect(this, &PQCSettings::imageviewRescalingSmoothChanged, this, [this]() { saveChangedValue("imageviewRescalingSmooth", m_imageviewRescalingSmooth); });
    connect(this, &PQCSettings::imageviewRescalingWhichImagesChanged, this, [this]() { saveChangedValue("imageviewRescalingWhichImages", m_imageviewRescalingWhichImages); });
    connect(this, &PQCSettings::imageviewResetViewAutoHideTimeoutChanged, this, [this]() { saveChangedValue("imageviewResetViewAutoHideTimeout", m_imageviewResetViewAutoHideTimeout); });
    connect(this, &PQCSettings::imageviewResetViewShowChanged, this, [this]() { saveChangedValue("imageviewResetViewShow", m_imageviewResetViewShow); });
    connect(this, &PQCSettings::imageviewRespectDevicePixelRatioChanged, this, [this]() { saveChangedValue("imageviewRespectDevicePixelRatio", m_imageviewRespectDevicePixelRatio); });
    connect(this, &PQCSettings::imageviewShowMinimapChanged, this, [this]() { saveChangedValue("imageviewShowMinimap", m_imageviewShowMinimap); });
    connect(this, &PQCSettings::imageviewSiblingFileMaxIterationsChanged, this, [this]() { saveChangedValue("imageviewSiblingFileMaxIterations", m_imageviewSiblingFileMaxIterations); });
    connect(this, &PQCSettings::imageviewSiblingFileMaxLevelUpChanged, this, [this]() { saveChangedValue("imageviewSiblingFileMaxLevelUp", m_imageviewSiblingFileMaxLevelUp); });
    connect(this, &PQCSettings::imageviewSiblingFilemaxLevelDownChanged, this, [this]() { saveChangedValue("imageviewSiblingFilemaxLevelDown", m_imageviewSiblingFilemaxLevelDown); });
    connect(this, &PQCSettings::imageviewSortImagesAscendingChanged, this, [this]() { saveChangedValue("imageviewSortImagesAscending", m_imageviewSortImagesAscending); });
    connect(this, &PQCSettings::imageviewSortImagesByChanged, this, [this]() { saveChangedValue("imageviewSortImagesBy", m_imageviewSortImagesBy); });
    connect(this, &PQCSettings::imageviewTransparencyMarkerChanged, this, [this]() { saveChangedValue("imageviewTransparencyMarker", m_imageviewTransparencyMarker); });
    connect(this, &PQCSettings::imageviewUseMouseLeftButtonForImageMoveChanged, this, [this]() { saveChangedValue("imageviewUseMouseLeftButtonForImageMove", m_imageviewUseMouseLeftButtonForImageMove); });
    connect(this, &PQCSettings::imageviewUseMouseWheelForImageMoveChanged, this, [this]() { saveChangedValue("imageviewUseMouseWheelForImageMove", m_imageviewUseMouseWheelForImageMove); });
    connect(this, &PQCSettings::imageviewZoomMaxChanged, this, [this]() { saveChangedValue("imageviewZoomMax", m_imageviewZoomMax); });
    connect(this, &PQCSettings::imageviewZoomMaxEnabledChanged, this, [this]() { saveChangedValue("imageviewZoomMaxEnabled", m_imageviewZoomMaxEnabled); });
    connect(this, &PQCSettings::imageviewZoomMinChanged, this, [this]() { saveChangedValue("imageviewZoomMin", m_imageviewZoomMin); });
    connect(this, &PQCSettings::imageviewZoomMinEnabledChanged, this, [this]() { saveChangedValue("imageviewZoomMinEnabled", m_imageviewZoomMinEnabled); });
    connect(this, &PQCSettings::imageviewZoomSpeedChanged, this, [this]() { saveChangedValue("imageviewZoomSpeed", m_imageviewZoomSpeed); });
    connect(this, &PQCSettings::imageviewZoomSpeedRelativeChanged, this, [this]() { saveChangedValue("imageviewZoomSpeedRelative", m_imageviewZoomSpeedRelative); });
    connect(this, &PQCSettings::imageviewZoomToCenterChanged, this, [this]() { saveChangedValue("imageviewZoomToCenter", m_imageviewZoomToCenter); });
    // table: interface
    connect(this, &PQCSettings::interfaceAccentColorChanged, this, [this]() { saveChangedValue("interfaceAccentColor", m_interfaceAccentColor); });
    connect(this, &PQCSettings::interfaceAllowMultipleInstancesChanged, this, [this]() { saveChangedValue("interfaceAllowMultipleInstances", m_interfaceAllowMultipleInstances); });
    connect(this, &PQCSettings::interfaceBackgroundCustomOverlayChanged, this, [this]() { saveChangedValue("interfaceBackgroundCustomOverlay", m_interfaceBackgroundCustomOverlay); });
    connect(this, &PQCSettings::interfaceBackgroundCustomOverlayColorChanged, this, [this]() { saveChangedValue("interfaceBackgroundCustomOverlayColor", m_interfaceBackgroundCustomOverlayColor); });
    connect(this, &PQCSettings::interfaceBackgroundFullyTransparentChanged, this, [this]() { saveChangedValue("interfaceBackgroundFullyTransparent", m_interfaceBackgroundFullyTransparent); });
    connect(this, &PQCSettings::interfaceBackgroundImageCenterChanged, this, [this]() { saveChangedValue("interfaceBackgroundImageCenter", m_interfaceBackgroundImageCenter); });
    connect(this, &PQCSettings::interfaceBackgroundImagePathChanged, this, [this]() { saveChangedValue("interfaceBackgroundImagePath", m_interfaceBackgroundImagePath); });
    connect(this, &PQCSettings::interfaceBackgroundImageScaleChanged, this, [this]() { saveChangedValue("interfaceBackgroundImageScale", m_interfaceBackgroundImageScale); });
    connect(this, &PQCSettings::interfaceBackgroundImageScaleCropChanged, this, [this]() { saveChangedValue("interfaceBackgroundImageScaleCrop", m_interfaceBackgroundImageScaleCrop); });
    connect(this, &PQCSettings::interfaceBackgroundImageScreenshotChanged, this, [this]() { saveChangedValue("interfaceBackgroundImageScreenshot", m_interfaceBackgroundImageScreenshot); });
    connect(this, &PQCSettings::interfaceBackgroundImageStretchChanged, this, [this]() { saveChangedValue("interfaceBackgroundImageStretch", m_interfaceBackgroundImageStretch); });
    connect(this, &PQCSettings::interfaceBackgroundImageTileChanged, this, [this]() { saveChangedValue("interfaceBackgroundImageTile", m_interfaceBackgroundImageTile); });
    connect(this, &PQCSettings::interfaceBackgroundImageUseChanged, this, [this]() { saveChangedValue("interfaceBackgroundImageUse", m_interfaceBackgroundImageUse); });
    connect(this, &PQCSettings::interfaceBackgroundSolidChanged, this, [this]() { saveChangedValue("interfaceBackgroundSolid", m_interfaceBackgroundSolid); });
    connect(this, &PQCSettings::interfaceBlurElementsInBackgroundChanged, this, [this]() { saveChangedValue("interfaceBlurElementsInBackground", m_interfaceBlurElementsInBackground); });
    connect(this, &PQCSettings::interfaceCloseOnEmptyBackgroundChanged, this, [this]() { saveChangedValue("interfaceCloseOnEmptyBackground", m_interfaceCloseOnEmptyBackground); });
    connect(this, &PQCSettings::interfaceDoubleClickThresholdChanged, this, [this]() { saveChangedValue("interfaceDoubleClickThreshold", m_interfaceDoubleClickThreshold); });
    connect(this, &PQCSettings::interfaceEdgeBottomActionChanged, this, [this]() { saveChangedValue("interfaceEdgeBottomAction", m_interfaceEdgeBottomAction); });
    connect(this, &PQCSettings::interfaceEdgeLeftActionChanged, this, [this]() { saveChangedValue("interfaceEdgeLeftAction", m_interfaceEdgeLeftAction); });
    connect(this, &PQCSettings::interfaceEdgeRightActionChanged, this, [this]() { saveChangedValue("interfaceEdgeRightAction", m_interfaceEdgeRightAction); });
    connect(this, &PQCSettings::interfaceEdgeTopActionChanged, this, [this]() { saveChangedValue("interfaceEdgeTopAction", m_interfaceEdgeTopAction); });
    connect(this, &PQCSettings::interfaceFlickAdjustSpeedChanged, this, [this]() { saveChangedValue("interfaceFlickAdjustSpeed", m_interfaceFlickAdjustSpeed); });
    connect(this, &PQCSettings::interfaceFlickAdjustSpeedSpeedupChanged, this, [this]() { saveChangedValue("interfaceFlickAdjustSpeedSpeedup", m_interfaceFlickAdjustSpeedSpeedup); });
    connect(this, &PQCSettings::interfaceFontBoldWeightChanged, this, [this]() { saveChangedValue("interfaceFontBoldWeight", m_interfaceFontBoldWeight); });
    connect(this, &PQCSettings::interfaceFontNormalWeightChanged, this, [this]() { saveChangedValue("interfaceFontNormalWeight", m_interfaceFontNormalWeight); });
    connect(this, &PQCSettings::interfaceHotEdgeSizeChanged, this, [this]() { saveChangedValue("interfaceHotEdgeSize", m_interfaceHotEdgeSize); });
    connect(this, &PQCSettings::interfaceKeepWindowOnTopChanged, this, [this]() { saveChangedValue("interfaceKeepWindowOnTop", m_interfaceKeepWindowOnTop); });
    connect(this, &PQCSettings::interfaceLanguageChanged, this, [this]() { saveChangedValue("interfaceLanguage", m_interfaceLanguage); });
    connect(this, &PQCSettings::interfaceMinimapPopoutChanged, this, [this]() { saveChangedValue("interfaceMinimapPopout", m_interfaceMinimapPopout); });
    connect(this, &PQCSettings::interfaceNavigateOnEmptyBackgroundChanged, this, [this]() { saveChangedValue("interfaceNavigateOnEmptyBackground", m_interfaceNavigateOnEmptyBackground); });
    connect(this, &PQCSettings::interfaceNavigationFloatingChanged, this, [this]() { saveChangedValue("interfaceNavigationFloating", m_interfaceNavigationFloating); });
    connect(this, &PQCSettings::interfaceNotificationDistanceFromEdgeChanged, this, [this]() { saveChangedValue("interfaceNotificationDistanceFromEdge", m_interfaceNotificationDistanceFromEdge); });
    connect(this, &PQCSettings::interfaceNotificationLocationChanged, this, [this]() { saveChangedValue("interfaceNotificationLocation", m_interfaceNotificationLocation); });
    connect(this, &PQCSettings::interfaceNotificationTryNativeChanged, this, [this]() { saveChangedValue("interfaceNotificationTryNative", m_interfaceNotificationTryNative); });
    connect(this, &PQCSettings::interfacePopoutAboutChanged, this, [this]() { saveChangedValue("interfacePopoutAbout", m_interfacePopoutAbout); });
    connect(this, &PQCSettings::interfacePopoutAdvancedSortChanged, this, [this]() { saveChangedValue("interfacePopoutAdvancedSort", m_interfacePopoutAdvancedSort); });
    connect(this, &PQCSettings::interfacePopoutChromecastChanged, this, [this]() { saveChangedValue("interfacePopoutChromecast", m_interfacePopoutChromecast); });
    connect(this, &PQCSettings::interfacePopoutExportChanged, this, [this]() { saveChangedValue("interfacePopoutExport", m_interfacePopoutExport); });
    connect(this, &PQCSettings::interfacePopoutFileDeleteChanged, this, [this]() { saveChangedValue("interfacePopoutFileDelete", m_interfacePopoutFileDelete); });
    connect(this, &PQCSettings::interfacePopoutFileDialogChanged, this, [this]() { saveChangedValue("interfacePopoutFileDialog", m_interfacePopoutFileDialog); });
    connect(this, &PQCSettings::interfacePopoutFileDialogNonModalChanged, this, [this]() { saveChangedValue("interfacePopoutFileDialogNonModal", m_interfacePopoutFileDialogNonModal); });
    connect(this, &PQCSettings::interfacePopoutFileRenameChanged, this, [this]() { saveChangedValue("interfacePopoutFileRename", m_interfacePopoutFileRename); });
    connect(this, &PQCSettings::interfacePopoutFilterChanged, this, [this]() { saveChangedValue("interfacePopoutFilter", m_interfacePopoutFilter); });
    connect(this, &PQCSettings::interfacePopoutFindChanged, this, [this]() { saveChangedValue("interfacePopoutFind", m_interfacePopoutFind); });
    connect(this, &PQCSettings::interfacePopoutImgurChanged, this, [this]() { saveChangedValue("interfacePopoutImgur", m_interfacePopoutImgur); });
    connect(this, &PQCSettings::interfacePopoutMainMenuChanged, this, [this]() { saveChangedValue("interfacePopoutMainMenu", m_interfacePopoutMainMenu); });
    connect(this, &PQCSettings::interfacePopoutMapExplorerChanged, this, [this]() { saveChangedValue("interfacePopoutMapExplorer", m_interfacePopoutMapExplorer); });
    connect(this, &PQCSettings::interfacePopoutMapExplorerNonModalChanged, this, [this]() { saveChangedValue("interfacePopoutMapExplorerNonModal", m_interfacePopoutMapExplorerNonModal); });
    connect(this, &PQCSettings::interfacePopoutMetadataChanged, this, [this]() { saveChangedValue("interfacePopoutMetadata", m_interfacePopoutMetadata); });
    connect(this, &PQCSettings::interfacePopoutSettingsManagerChanged, this, [this]() { saveChangedValue("interfacePopoutSettingsManager", m_interfacePopoutSettingsManager); });
    connect(this, &PQCSettings::interfacePopoutSettingsManagerNonModalChanged, this, [this]() { saveChangedValue("interfacePopoutSettingsManagerNonModal", m_interfacePopoutSettingsManagerNonModal); });
    connect(this, &PQCSettings::interfacePopoutSlideshowControlsChanged, this, [this]() { saveChangedValue("interfacePopoutSlideshowControls", m_interfacePopoutSlideshowControls); });
    connect(this, &PQCSettings::interfacePopoutSlideshowSetupChanged, this, [this]() { saveChangedValue("interfacePopoutSlideshowSetup", m_interfacePopoutSlideshowSetup); });
    connect(this, &PQCSettings::interfacePopoutWhenWindowIsSmallChanged, this, [this]() { saveChangedValue("interfacePopoutWhenWindowIsSmall", m_interfacePopoutWhenWindowIsSmall); });
    connect(this, &PQCSettings::interfaceQuickActionsChanged, this, [this]() { saveChangedValue("interfaceQuickActions", m_interfaceQuickActions); });
    connect(this, &PQCSettings::interfaceQuickActionsHeightChanged, this, [this]() { saveChangedValue("interfaceQuickActionsHeight", m_interfaceQuickActionsHeight); });
    connect(this, &PQCSettings::interfaceQuickActionsItemsChanged, this, [this]() { saveChangedValue("interfaceQuickActionsItems", m_interfaceQuickActionsItems); });
    connect(this, &PQCSettings::interfaceRememberLastImageChanged, this, [this]() { saveChangedValue("interfaceRememberLastImage", m_interfaceRememberLastImage); });
    connect(this, &PQCSettings::interfaceSaveWindowGeometryChanged, this, [this]() { saveChangedValue("interfaceSaveWindowGeometry", m_interfaceSaveWindowGeometry); });
    connect(this, &PQCSettings::interfaceStatusInfoAutoHideChanged, this, [this]() { saveChangedValue("interfaceStatusInfoAutoHide", m_interfaceStatusInfoAutoHide); });
    connect(this, &PQCSettings::interfaceStatusInfoAutoHideTimeoutChanged, this, [this]() { saveChangedValue("interfaceStatusInfoAutoHideTimeout", m_interfaceStatusInfoAutoHideTimeout); });
    connect(this, &PQCSettings::interfaceStatusInfoAutoHideTopEdgeChanged, this, [this]() { saveChangedValue("interfaceStatusInfoAutoHideTopEdge", m_interfaceStatusInfoAutoHideTopEdge); });
    connect(this, &PQCSettings::interfaceStatusInfoFontSizeChanged, this, [this]() { saveChangedValue("interfaceStatusInfoFontSize", m_interfaceStatusInfoFontSize); });
    connect(this, &PQCSettings::interfaceStatusInfoListChanged, this, [this]() { saveChangedValue("interfaceStatusInfoList", m_interfaceStatusInfoList); });
    connect(this, &PQCSettings::interfaceStatusInfoManageWindowChanged, this, [this]() { saveChangedValue("interfaceStatusInfoManageWindow", m_interfaceStatusInfoManageWindow); });
    connect(this, &PQCSettings::interfaceStatusInfoPositionChanged, this, [this]() { saveChangedValue("interfaceStatusInfoPosition", m_interfaceStatusInfoPosition); });
    connect(this, &PQCSettings::interfaceStatusInfoShowChanged, this, [this]() { saveChangedValue("interfaceStatusInfoShow", m_interfaceStatusInfoShow); });
    connect(this, &PQCSettings::interfaceStatusInfoShowImageChangeChanged, this, [this]() { saveChangedValue("interfaceStatusInfoShowImageChange", m_interfaceStatusInfoShowImageChange); });
    connect(this, &PQCSettings::interfaceTrayIconChanged, this, [this]() { saveChangedValue("interfaceTrayIcon", m_interfaceTrayIcon); });
    connect(this, &PQCSettings::interfaceTrayIconHideResetChanged, this, [this]() { saveChangedValue("interfaceTrayIconHideReset", m_interfaceTrayIconHideReset); });
    connect(this, &PQCSettings::interfaceTrayIconMonochromeChanged, this, [this]() { saveChangedValue("interfaceTrayIconMonochrome", m_interfaceTrayIconMonochrome); });
    connect(this, &PQCSettings::interfaceWindowButtonsAutoHideChanged, this, [this]() { saveChangedValue("interfaceWindowButtonsAutoHide", m_interfaceWindowButtonsAutoHide); });
    connect(this, &PQCSettings::interfaceWindowButtonsAutoHideTimeoutChanged, this, [this]() { saveChangedValue("interfaceWindowButtonsAutoHideTimeout", m_interfaceWindowButtonsAutoHideTimeout); });
    connect(this, &PQCSettings::interfaceWindowButtonsAutoHideTopEdgeChanged, this, [this]() { saveChangedValue("interfaceWindowButtonsAutoHideTopEdge", m_interfaceWindowButtonsAutoHideTopEdge); });
    connect(this, &PQCSettings::interfaceWindowButtonsFollowAccentColorChanged, this, [this]() { saveChangedValue("interfaceWindowButtonsFollowAccentColor", m_interfaceWindowButtonsFollowAccentColor); });
    connect(this, &PQCSettings::interfaceWindowButtonsItemsChanged, this, [this]() { saveChangedValue("interfaceWindowButtonsItems", m_interfaceWindowButtonsItems); });
    connect(this, &PQCSettings::interfaceWindowButtonsShowChanged, this, [this]() { saveChangedValue("interfaceWindowButtonsShow", m_interfaceWindowButtonsShow); });
    connect(this, &PQCSettings::interfaceWindowButtonsSizeChanged, this, [this]() { saveChangedValue("interfaceWindowButtonsSize", m_interfaceWindowButtonsSize); });
    connect(this, &PQCSettings::interfaceWindowDecorationChanged, this, [this]() { saveChangedValue("interfaceWindowDecoration", m_interfaceWindowDecoration); });
    connect(this, &PQCSettings::interfaceWindowDecorationOnEmptyBackgroundChanged, this, [this]() { saveChangedValue("interfaceWindowDecorationOnEmptyBackground", m_interfaceWindowDecorationOnEmptyBackground); });
    connect(this, &PQCSettings::interfaceWindowModeChanged, this, [this]() { saveChangedValue("interfaceWindowMode", m_interfaceWindowMode); });
    // table: mainmenu
    connect(this, &PQCSettings::mainmenuElementHeightDynamicChanged, this, [this]() { saveChangedValue("mainmenuElementHeightDynamic", m_mainmenuElementHeightDynamic); });
    connect(this, &PQCSettings::mainmenuElementPositionChanged, this, [this]() { saveChangedValue("mainmenuElementPosition", m_mainmenuElementPosition); });
    connect(this, &PQCSettings::mainmenuElementSizeChanged, this, [this]() { saveChangedValue("mainmenuElementSize", m_mainmenuElementSize); });
    connect(this, &PQCSettings::mainmenuElementWidthChanged, this, [this]() { saveChangedValue("mainmenuElementWidth", m_mainmenuElementWidth); });
    connect(this, &PQCSettings::mainmenuShowExternalChanged, this, [this]() { saveChangedValue("mainmenuShowExternal", m_mainmenuShowExternal); });
    // table: mapview
    connect(this, &PQCSettings::mapviewCurrentPositionChanged, this, [this]() { saveChangedValue("mapviewCurrentPosition", m_mapviewCurrentPosition); });
    connect(this, &PQCSettings::mapviewCurrentSizeChanged, this, [this]() { saveChangedValue("mapviewCurrentSize", m_mapviewCurrentSize); });
    connect(this, &PQCSettings::mapviewCurrentVisibleChanged, this, [this]() { saveChangedValue("mapviewCurrentVisible", m_mapviewCurrentVisible); });
    connect(this, &PQCSettings::mapviewExplorerThumbnailsScaleCropChanged, this, [this]() { saveChangedValue("mapviewExplorerThumbnailsScaleCrop", m_mapviewExplorerThumbnailsScaleCrop); });
    connect(this, &PQCSettings::mapviewExplorerThumbnailsZoomLevelChanged, this, [this]() { saveChangedValue("mapviewExplorerThumbnailsZoomLevel", m_mapviewExplorerThumbnailsZoomLevel); });
    // table: metadata
    connect(this, &PQCSettings::metadataAutoRotationChanged, this, [this]() { saveChangedValue("metadataAutoRotation", m_metadataAutoRotation); });
    connect(this, &PQCSettings::metadataCopyrightChanged, this, [this]() { saveChangedValue("metadataCopyright", m_metadataCopyright); });
    connect(this, &PQCSettings::metadataDimensionsChanged, this, [this]() { saveChangedValue("metadataDimensions", m_metadataDimensions); });
    connect(this, &PQCSettings::metadataElementFloatingChanged, this, [this]() { saveChangedValue("metadataElementFloating", m_metadataElementFloating); });
    connect(this, &PQCSettings::metadataElementHeightDynamicChanged, this, [this]() { saveChangedValue("metadataElementHeightDynamic", m_metadataElementHeightDynamic); });
    connect(this, &PQCSettings::metadataElementPositionChanged, this, [this]() { saveChangedValue("metadataElementPosition", m_metadataElementPosition); });
    connect(this, &PQCSettings::metadataElementSizeChanged, this, [this]() { saveChangedValue("metadataElementSize", m_metadataElementSize); });
    connect(this, &PQCSettings::metadataElementVisibleChanged, this, [this]() { saveChangedValue("metadataElementVisible", m_metadataElementVisible); });
    connect(this, &PQCSettings::metadataExposureTimeChanged, this, [this]() { saveChangedValue("metadataExposureTime", m_metadataExposureTime); });
    connect(this, &PQCSettings::metadataFLengthChanged, this, [this]() { saveChangedValue("metadataFLength", m_metadataFLength); });
    connect(this, &PQCSettings::metadataFNumberChanged, this, [this]() { saveChangedValue("metadataFNumber", m_metadataFNumber); });
    connect(this, &PQCSettings::metadataFaceTagsBorderChanged, this, [this]() { saveChangedValue("metadataFaceTagsBorder", m_metadataFaceTagsBorder); });
    connect(this, &PQCSettings::metadataFaceTagsBorderColorChanged, this, [this]() { saveChangedValue("metadataFaceTagsBorderColor", m_metadataFaceTagsBorderColor); });
    connect(this, &PQCSettings::metadataFaceTagsBorderWidthChanged, this, [this]() { saveChangedValue("metadataFaceTagsBorderWidth", m_metadataFaceTagsBorderWidth); });
    connect(this, &PQCSettings::metadataFaceTagsEnabledChanged, this, [this]() { saveChangedValue("metadataFaceTagsEnabled", m_metadataFaceTagsEnabled); });
    connect(this, &PQCSettings::metadataFaceTagsFontSizeChanged, this, [this]() { saveChangedValue("metadataFaceTagsFontSize", m_metadataFaceTagsFontSize); });
    connect(this, &PQCSettings::metadataFaceTagsVisibilityChanged, this, [this]() { saveChangedValue("metadataFaceTagsVisibility", m_metadataFaceTagsVisibility); });
    connect(this, &PQCSettings::metadataFileSizeChanged, this, [this]() { saveChangedValue("metadataFileSize", m_metadataFileSize); });
    connect(this, &PQCSettings::metadataFileTypeChanged, this, [this]() { saveChangedValue("metadataFileType", m_metadataFileType); });
    connect(this, &PQCSettings::metadataFilenameChanged, this, [this]() { saveChangedValue("metadataFilename", m_metadataFilename); });
    connect(this, &PQCSettings::metadataFlashChanged, this, [this]() { saveChangedValue("metadataFlash", m_metadataFlash); });
    connect(this, &PQCSettings::metadataGpsChanged, this, [this]() { saveChangedValue("metadataGps", m_metadataGps); });
    connect(this, &PQCSettings::metadataGpsMapChanged, this, [this]() { saveChangedValue("metadataGpsMap", m_metadataGpsMap); });
    connect(this, &PQCSettings::metadataImageNumberChanged, this, [this]() { saveChangedValue("metadataImageNumber", m_metadataImageNumber); });
    connect(this, &PQCSettings::metadataIsoChanged, this, [this]() { saveChangedValue("metadataIso", m_metadataIso); });
    connect(this, &PQCSettings::metadataKeywordsChanged, this, [this]() { saveChangedValue("metadataKeywords", m_metadataKeywords); });
    connect(this, &PQCSettings::metadataLightSourceChanged, this, [this]() { saveChangedValue("metadataLightSource", m_metadataLightSource); });
    connect(this, &PQCSettings::metadataLocationChanged, this, [this]() { saveChangedValue("metadataLocation", m_metadataLocation); });
    connect(this, &PQCSettings::metadataMakeChanged, this, [this]() { saveChangedValue("metadataMake", m_metadataMake); });
    connect(this, &PQCSettings::metadataModelChanged, this, [this]() { saveChangedValue("metadataModel", m_metadataModel); });
    connect(this, &PQCSettings::metadataSceneTypeChanged, this, [this]() { saveChangedValue("metadataSceneType", m_metadataSceneType); });
    connect(this, &PQCSettings::metadataSideBarChanged, this, [this]() { saveChangedValue("metadataSideBar", m_metadataSideBar); });
    connect(this, &PQCSettings::metadataSideBarLocationChanged, this, [this]() { saveChangedValue("metadataSideBarLocation", m_metadataSideBarLocation); });
    connect(this, &PQCSettings::metadataSideBarWidthChanged, this, [this]() { saveChangedValue("metadataSideBarWidth", m_metadataSideBarWidth); });
    connect(this, &PQCSettings::metadataSoftwareChanged, this, [this]() { saveChangedValue("metadataSoftware", m_metadataSoftware); });
    connect(this, &PQCSettings::metadataTimeChanged, this, [this]() { saveChangedValue("metadataTime", m_metadataTime); });
    // table: slideshow
    connect(this, &PQCSettings::slideshowHideLabelsChanged, this, [this]() { saveChangedValue("slideshowHideLabels", m_slideshowHideLabels); });
    connect(this, &PQCSettings::slideshowHideWindowButtonsChanged, this, [this]() { saveChangedValue("slideshowHideWindowButtons", m_slideshowHideWindowButtons); });
    connect(this, &PQCSettings::slideshowImageTransitionChanged, this, [this]() { saveChangedValue("slideshowImageTransition", m_slideshowImageTransition); });
    connect(this, &PQCSettings::slideshowIncludeSubFoldersChanged, this, [this]() { saveChangedValue("slideshowIncludeSubFolders", m_slideshowIncludeSubFolders); });
    connect(this, &PQCSettings::slideshowLoopChanged, this, [this]() { saveChangedValue("slideshowLoop", m_slideshowLoop); });
    connect(this, &PQCSettings::slideshowMusicChanged, this, [this]() { saveChangedValue("slideshowMusic", m_slideshowMusic); });
    connect(this, &PQCSettings::slideshowMusicFileChanged, this, [this]() { saveChangedValue("slideshowMusicFile", m_slideshowMusicFile); });
    connect(this, &PQCSettings::slideshowMusicFilesChanged, this, [this]() { saveChangedValue("slideshowMusicFiles", m_slideshowMusicFiles); });
    connect(this, &PQCSettings::slideshowMusicShuffleChanged, this, [this]() { saveChangedValue("slideshowMusicShuffle", m_slideshowMusicShuffle); });
    connect(this, &PQCSettings::slideshowMusicVolumeVideosChanged, this, [this]() { saveChangedValue("slideshowMusicVolumeVideos", m_slideshowMusicVolumeVideos); });
    connect(this, &PQCSettings::slideshowShuffleChanged, this, [this]() { saveChangedValue("slideshowShuffle", m_slideshowShuffle); });
    connect(this, &PQCSettings::slideshowTimeChanged, this, [this]() { saveChangedValue("slideshowTime", m_slideshowTime); });
    connect(this, &PQCSettings::slideshowTypeAnimationChanged, this, [this]() { saveChangedValue("slideshowTypeAnimation", m_slideshowTypeAnimation); });
    // table: thumbnails
    connect(this, &PQCSettings::thumbnailsCacheChanged, this, [this]() { saveChangedValue("thumbnailsCache", m_thumbnailsCache); });
    connect(this, &PQCSettings::thumbnailsCacheBaseDirDefaultChanged, this, [this]() { saveChangedValue("thumbnailsCacheBaseDirDefault", m_thumbnailsCacheBaseDirDefault); });
    connect(this, &PQCSettings::thumbnailsCacheBaseDirLocationChanged, this, [this]() { saveChangedValue("thumbnailsCacheBaseDirLocation", m_thumbnailsCacheBaseDirLocation); });
    connect(this, &PQCSettings::thumbnailsCenterOnActiveChanged, this, [this]() { saveChangedValue("thumbnailsCenterOnActive", m_thumbnailsCenterOnActive); });
    connect(this, &PQCSettings::thumbnailsCropToFitChanged, this, [this]() { saveChangedValue("thumbnailsCropToFit", m_thumbnailsCropToFit); });
    connect(this, &PQCSettings::thumbnailsDisableChanged, this, [this]() { saveChangedValue("thumbnailsDisable", m_thumbnailsDisable); });
    connect(this, &PQCSettings::thumbnailsExcludeDropBoxChanged, this, [this]() { saveChangedValue("thumbnailsExcludeDropBox", m_thumbnailsExcludeDropBox); });
    connect(this, &PQCSettings::thumbnailsExcludeFoldersChanged, this, [this]() { saveChangedValue("thumbnailsExcludeFolders", m_thumbnailsExcludeFolders); });
    connect(this, &PQCSettings::thumbnailsExcludeNetworkSharesChanged, this, [this]() { saveChangedValue("thumbnailsExcludeNetworkShares", m_thumbnailsExcludeNetworkShares); });
    connect(this, &PQCSettings::thumbnailsExcludeNextcloudChanged, this, [this]() { saveChangedValue("thumbnailsExcludeNextcloud", m_thumbnailsExcludeNextcloud); });
    connect(this, &PQCSettings::thumbnailsExcludeOwnCloudChanged, this, [this]() { saveChangedValue("thumbnailsExcludeOwnCloud", m_thumbnailsExcludeOwnCloud); });
    connect(this, &PQCSettings::thumbnailsFilenameChanged, this, [this]() { saveChangedValue("thumbnailsFilename", m_thumbnailsFilename); });
    connect(this, &PQCSettings::thumbnailsFontSizeChanged, this, [this]() { saveChangedValue("thumbnailsFontSize", m_thumbnailsFontSize); });
    connect(this, &PQCSettings::thumbnailsHighlightAnimationChanged, this, [this]() { saveChangedValue("thumbnailsHighlightAnimation", m_thumbnailsHighlightAnimation); });
    connect(this, &PQCSettings::thumbnailsHighlightAnimationLiftUpChanged, this, [this]() { saveChangedValue("thumbnailsHighlightAnimationLiftUp", m_thumbnailsHighlightAnimationLiftUp); });
    connect(this, &PQCSettings::thumbnailsIconsOnlyChanged, this, [this]() { saveChangedValue("thumbnailsIconsOnly", m_thumbnailsIconsOnly); });
    connect(this, &PQCSettings::thumbnailsInactiveTransparentChanged, this, [this]() { saveChangedValue("thumbnailsInactiveTransparent", m_thumbnailsInactiveTransparent); });
    connect(this, &PQCSettings::thumbnailsMaxNumberThreadsChanged, this, [this]() { saveChangedValue("thumbnailsMaxNumberThreads", m_thumbnailsMaxNumberThreads); });
    connect(this, &PQCSettings::thumbnailsSameHeightVaryWidthChanged, this, [this]() { saveChangedValue("thumbnailsSameHeightVaryWidth", m_thumbnailsSameHeightVaryWidth); });
    connect(this, &PQCSettings::thumbnailsSizeChanged, this, [this]() { saveChangedValue("thumbnailsSize", m_thumbnailsSize); });
    connect(this, &PQCSettings::thumbnailsSmallThumbnailsKeepSmallChanged, this, [this]() { saveChangedValue("thumbnailsSmallThumbnailsKeepSmall", m_thumbnailsSmallThumbnailsKeepSmall); });
    connect(this, &PQCSettings::thumbnailsSpacingChanged, this, [this]() { saveChangedValue("thumbnailsSpacing", m_thumbnailsSpacing); });
    connect(this, &PQCSettings::thumbnailsTooltipChanged, this, [this]() { saveChangedValue("thumbnailsTooltip", m_thumbnailsTooltip); });
    connect(this, &PQCSettings::thumbnailsVisibilityChanged, this, [this]() { saveChangedValue("thumbnailsVisibility", m_thumbnailsVisibility); });

    /******************************************************/

    connect(&PQCNotifyCPP::get(), &PQCNotifyCPP::disableColorSpaceSupport, this, [this]() {{ setImageviewColorSpaceEnable(false); }});

}

PQCSettings::~PQCSettings() {{
    QSqlDatabase::removeDatabase("defaultsettings");
    QSqlDatabase::removeDatabase("settings");
    if(dbCommitTimer != nullptr) {{
        delete dbCommitTimer;
    }}
}}

bool PQCSettings::getFiledialogDetailsTooltip() const {
    return m_filedialogDetailsTooltip;
}

void PQCSettings::setFiledialogDetailsTooltip(const bool val) {
    if(val != m_filedialogDetailsTooltip) {
        m_filedialogDetailsTooltip = val;
        Q_EMIT filedialogDetailsTooltipChanged();
    }
}

const bool PQCSettings::getDefaultForFiledialogDetailsTooltip() const {
        return true;
}

void PQCSettings::setDefaultForFiledialogDetailsTooltip() {
    if(true != m_filedialogDetailsTooltip) {
        m_filedialogDetailsTooltip = true;
        Q_EMIT filedialogDetailsTooltipChanged();
    }
}

bool PQCSettings::getFiledialogDevices() const {
    return m_filedialogDevices;
}

void PQCSettings::setFiledialogDevices(const bool val) {
    if(val != m_filedialogDevices) {
        m_filedialogDevices = val;
        Q_EMIT filedialogDevicesChanged();
    }
}

const bool PQCSettings::getDefaultForFiledialogDevices() const {
        return false;
}

void PQCSettings::setDefaultForFiledialogDevices() {
    if(false != m_filedialogDevices) {
        m_filedialogDevices = false;
        Q_EMIT filedialogDevicesChanged();
    }
}

bool PQCSettings::getFiledialogDevicesShowTmpfs() const {
    return m_filedialogDevicesShowTmpfs;
}

void PQCSettings::setFiledialogDevicesShowTmpfs(const bool val) {
    if(val != m_filedialogDevicesShowTmpfs) {
        m_filedialogDevicesShowTmpfs = val;
        Q_EMIT filedialogDevicesShowTmpfsChanged();
    }
}

const bool PQCSettings::getDefaultForFiledialogDevicesShowTmpfs() const {
        return false;
}

void PQCSettings::setDefaultForFiledialogDevicesShowTmpfs() {
    if(false != m_filedialogDevicesShowTmpfs) {
        m_filedialogDevicesShowTmpfs = false;
        Q_EMIT filedialogDevicesShowTmpfsChanged();
    }
}

bool PQCSettings::getFiledialogDragDropFileviewGrid() const {
    return m_filedialogDragDropFileviewGrid;
}

void PQCSettings::setFiledialogDragDropFileviewGrid(const bool val) {
    if(val != m_filedialogDragDropFileviewGrid) {
        m_filedialogDragDropFileviewGrid = val;
        Q_EMIT filedialogDragDropFileviewGridChanged();
    }
}

const bool PQCSettings::getDefaultForFiledialogDragDropFileviewGrid() const {
        return false;
}

void PQCSettings::setDefaultForFiledialogDragDropFileviewGrid() {
    if(false != m_filedialogDragDropFileviewGrid) {
        m_filedialogDragDropFileviewGrid = false;
        Q_EMIT filedialogDragDropFileviewGridChanged();
    }
}

bool PQCSettings::getFiledialogDragDropFileviewList() const {
    return m_filedialogDragDropFileviewList;
}

void PQCSettings::setFiledialogDragDropFileviewList(const bool val) {
    if(val != m_filedialogDragDropFileviewList) {
        m_filedialogDragDropFileviewList = val;
        Q_EMIT filedialogDragDropFileviewListChanged();
    }
}

const bool PQCSettings::getDefaultForFiledialogDragDropFileviewList() const {
        return true;
}

void PQCSettings::setDefaultForFiledialogDragDropFileviewList() {
    if(true != m_filedialogDragDropFileviewList) {
        m_filedialogDragDropFileviewList = true;
        Q_EMIT filedialogDragDropFileviewListChanged();
    }
}

bool PQCSettings::getFiledialogDragDropFileviewMasonry() const {
    return m_filedialogDragDropFileviewMasonry;
}

void PQCSettings::setFiledialogDragDropFileviewMasonry(const bool val) {
    if(val != m_filedialogDragDropFileviewMasonry) {
        m_filedialogDragDropFileviewMasonry = val;
        Q_EMIT filedialogDragDropFileviewMasonryChanged();
    }
}

const bool PQCSettings::getDefaultForFiledialogDragDropFileviewMasonry() const {
        return false;
}

void PQCSettings::setDefaultForFiledialogDragDropFileviewMasonry() {
    if(false != m_filedialogDragDropFileviewMasonry) {
        m_filedialogDragDropFileviewMasonry = false;
        Q_EMIT filedialogDragDropFileviewMasonryChanged();
    }
}

bool PQCSettings::getFiledialogDragDropPlaces() const {
    return m_filedialogDragDropPlaces;
}

void PQCSettings::setFiledialogDragDropPlaces(const bool val) {
    if(val != m_filedialogDragDropPlaces) {
        m_filedialogDragDropPlaces = val;
        Q_EMIT filedialogDragDropPlacesChanged();
    }
}

const bool PQCSettings::getDefaultForFiledialogDragDropPlaces() const {
        return true;
}

void PQCSettings::setDefaultForFiledialogDragDropPlaces() {
    if(true != m_filedialogDragDropPlaces) {
        m_filedialogDragDropPlaces = true;
        Q_EMIT filedialogDragDropPlacesChanged();
    }
}

int PQCSettings::getFiledialogElementPadding() const {
    return m_filedialogElementPadding;
}

void PQCSettings::setFiledialogElementPadding(const int val) {
    if(val != m_filedialogElementPadding) {
        m_filedialogElementPadding = val;
        Q_EMIT filedialogElementPaddingChanged();
    }
}

const int PQCSettings::getDefaultForFiledialogElementPadding() const {
        return 1;
}

void PQCSettings::setDefaultForFiledialogElementPadding() {
    if(1 != m_filedialogElementPadding) {
        m_filedialogElementPadding = 1;
    }
}

bool PQCSettings::getFiledialogFolderContentThumbnails() const {
    return m_filedialogFolderContentThumbnails;
}

void PQCSettings::setFiledialogFolderContentThumbnails(const bool val) {
    if(val != m_filedialogFolderContentThumbnails) {
        m_filedialogFolderContentThumbnails = val;
        Q_EMIT filedialogFolderContentThumbnailsChanged();
    }
}

const bool PQCSettings::getDefaultForFiledialogFolderContentThumbnails() const {
        return true;
}

void PQCSettings::setDefaultForFiledialogFolderContentThumbnails() {
    if(true != m_filedialogFolderContentThumbnails) {
        m_filedialogFolderContentThumbnails = true;
        Q_EMIT filedialogFolderContentThumbnailsChanged();
    }
}

bool PQCSettings::getFiledialogFolderContentThumbnailsAutoload() const {
    return m_filedialogFolderContentThumbnailsAutoload;
}

void PQCSettings::setFiledialogFolderContentThumbnailsAutoload(const bool val) {
    if(val != m_filedialogFolderContentThumbnailsAutoload) {
        m_filedialogFolderContentThumbnailsAutoload = val;
        Q_EMIT filedialogFolderContentThumbnailsAutoloadChanged();
    }
}

const bool PQCSettings::getDefaultForFiledialogFolderContentThumbnailsAutoload() const {
        return false;
}

void PQCSettings::setDefaultForFiledialogFolderContentThumbnailsAutoload() {
    if(false != m_filedialogFolderContentThumbnailsAutoload) {
        m_filedialogFolderContentThumbnailsAutoload = false;
        Q_EMIT filedialogFolderContentThumbnailsAutoloadChanged();
    }
}

bool PQCSettings::getFiledialogFolderContentThumbnailsLoop() const {
    return m_filedialogFolderContentThumbnailsLoop;
}

void PQCSettings::setFiledialogFolderContentThumbnailsLoop(const bool val) {
    if(val != m_filedialogFolderContentThumbnailsLoop) {
        m_filedialogFolderContentThumbnailsLoop = val;
        Q_EMIT filedialogFolderContentThumbnailsLoopChanged();
    }
}

const bool PQCSettings::getDefaultForFiledialogFolderContentThumbnailsLoop() const {
        return true;
}

void PQCSettings::setDefaultForFiledialogFolderContentThumbnailsLoop() {
    if(true != m_filedialogFolderContentThumbnailsLoop) {
        m_filedialogFolderContentThumbnailsLoop = true;
        Q_EMIT filedialogFolderContentThumbnailsLoopChanged();
    }
}

bool PQCSettings::getFiledialogFolderContentThumbnailsScaleCrop() const {
    return m_filedialogFolderContentThumbnailsScaleCrop;
}

void PQCSettings::setFiledialogFolderContentThumbnailsScaleCrop(const bool val) {
    if(val != m_filedialogFolderContentThumbnailsScaleCrop) {
        m_filedialogFolderContentThumbnailsScaleCrop = val;
        Q_EMIT filedialogFolderContentThumbnailsScaleCropChanged();
    }
}

const bool PQCSettings::getDefaultForFiledialogFolderContentThumbnailsScaleCrop() const {
        return true;
}

void PQCSettings::setDefaultForFiledialogFolderContentThumbnailsScaleCrop() {
    if(true != m_filedialogFolderContentThumbnailsScaleCrop) {
        m_filedialogFolderContentThumbnailsScaleCrop = true;
        Q_EMIT filedialogFolderContentThumbnailsScaleCropChanged();
    }
}

bool PQCSettings::getFiledialogFolderContentThumbnailsSortAscending() const {
    return m_filedialogFolderContentThumbnailsSortAscending;
}

void PQCSettings::setFiledialogFolderContentThumbnailsSortAscending(const bool val) {
    if(val != m_filedialogFolderContentThumbnailsSortAscending) {
        m_filedialogFolderContentThumbnailsSortAscending = val;
        Q_EMIT filedialogFolderContentThumbnailsSortAscendingChanged();
    }
}

const bool PQCSettings::getDefaultForFiledialogFolderContentThumbnailsSortAscending() const {
        return false;
}

void PQCSettings::setDefaultForFiledialogFolderContentThumbnailsSortAscending() {
    if(false != m_filedialogFolderContentThumbnailsSortAscending) {
        m_filedialogFolderContentThumbnailsSortAscending = false;
        Q_EMIT filedialogFolderContentThumbnailsSortAscendingChanged();
    }
}

QString PQCSettings::getFiledialogFolderContentThumbnailsSortBy() const {
    return m_filedialogFolderContentThumbnailsSortBy;
}

void PQCSettings::setFiledialogFolderContentThumbnailsSortBy(const QString val) {
    if(val != m_filedialogFolderContentThumbnailsSortBy) {
        m_filedialogFolderContentThumbnailsSortBy = val;
        Q_EMIT filedialogFolderContentThumbnailsSortByChanged();
    }
}

const QString PQCSettings::getDefaultForFiledialogFolderContentThumbnailsSortBy() const {
        return "default";
}

void PQCSettings::setDefaultForFiledialogFolderContentThumbnailsSortBy() {
    if("default" != m_filedialogFolderContentThumbnailsSortBy) {
        m_filedialogFolderContentThumbnailsSortBy = "default";
        Q_EMIT filedialogFolderContentThumbnailsSortByChanged();
    }
}

int PQCSettings::getFiledialogFolderContentThumbnailsSpeed() const {
    return m_filedialogFolderContentThumbnailsSpeed;
}

void PQCSettings::setFiledialogFolderContentThumbnailsSpeed(const int val) {
    if(val != m_filedialogFolderContentThumbnailsSpeed) {
        m_filedialogFolderContentThumbnailsSpeed = val;
        Q_EMIT filedialogFolderContentThumbnailsSpeedChanged();
    }
}

const int PQCSettings::getDefaultForFiledialogFolderContentThumbnailsSpeed() const {
        return 2;
}

void PQCSettings::setDefaultForFiledialogFolderContentThumbnailsSpeed() {
    if(2 != m_filedialogFolderContentThumbnailsSpeed) {
        m_filedialogFolderContentThumbnailsSpeed = 2;
    }
}

bool PQCSettings::getFiledialogLabelsShowGrid() const {
    return m_filedialogLabelsShowGrid;
}

void PQCSettings::setFiledialogLabelsShowGrid(const bool val) {
    if(val != m_filedialogLabelsShowGrid) {
        m_filedialogLabelsShowGrid = val;
        Q_EMIT filedialogLabelsShowGridChanged();
    }
}

const bool PQCSettings::getDefaultForFiledialogLabelsShowGrid() const {
        return true;
}

void PQCSettings::setDefaultForFiledialogLabelsShowGrid() {
    if(true != m_filedialogLabelsShowGrid) {
        m_filedialogLabelsShowGrid = true;
        Q_EMIT filedialogLabelsShowGridChanged();
    }
}

bool PQCSettings::getFiledialogLabelsShowMasonry() const {
    return m_filedialogLabelsShowMasonry;
}

void PQCSettings::setFiledialogLabelsShowMasonry(const bool val) {
    if(val != m_filedialogLabelsShowMasonry) {
        m_filedialogLabelsShowMasonry = val;
        Q_EMIT filedialogLabelsShowMasonryChanged();
    }
}

const bool PQCSettings::getDefaultForFiledialogLabelsShowMasonry() const {
        return false;
}

void PQCSettings::setDefaultForFiledialogLabelsShowMasonry() {
    if(false != m_filedialogLabelsShowMasonry) {
        m_filedialogLabelsShowMasonry = false;
        Q_EMIT filedialogLabelsShowMasonryChanged();
    }
}

QString PQCSettings::getFiledialogLayout() const {
    return m_filedialogLayout;
}

void PQCSettings::setFiledialogLayout(const QString val) {
    if(val != m_filedialogLayout) {
        m_filedialogLayout = val;
        Q_EMIT filedialogLayoutChanged();
    }
}

const QString PQCSettings::getDefaultForFiledialogLayout() const {
        return "grid";
}

void PQCSettings::setDefaultForFiledialogLayout() {
    if("grid" != m_filedialogLayout) {
        m_filedialogLayout = "grid";
        Q_EMIT filedialogLayoutChanged();
    }
}

bool PQCSettings::getFiledialogPlaces() const {
    return m_filedialogPlaces;
}

void PQCSettings::setFiledialogPlaces(const bool val) {
    if(val != m_filedialogPlaces) {
        m_filedialogPlaces = val;
        Q_EMIT filedialogPlacesChanged();
    }
}

const bool PQCSettings::getDefaultForFiledialogPlaces() const {
        return true;
}

void PQCSettings::setDefaultForFiledialogPlaces() {
    if(true != m_filedialogPlaces) {
        m_filedialogPlaces = true;
        Q_EMIT filedialogPlacesChanged();
    }
}

int PQCSettings::getFiledialogPlacesWidth() const {
    return m_filedialogPlacesWidth;
}

void PQCSettings::setFiledialogPlacesWidth(const int val) {
    if(val != m_filedialogPlacesWidth) {
        m_filedialogPlacesWidth = val;
        Q_EMIT filedialogPlacesWidthChanged();
    }
}

const int PQCSettings::getDefaultForFiledialogPlacesWidth() const {
        return 290;
}

void PQCSettings::setDefaultForFiledialogPlacesWidth() {
    if(290 != m_filedialogPlacesWidth) {
        m_filedialogPlacesWidth = 290;
    }
}

bool PQCSettings::getFiledialogPreview() const {
    return m_filedialogPreview;
}

void PQCSettings::setFiledialogPreview(const bool val) {
    if(val != m_filedialogPreview) {
        m_filedialogPreview = val;
        Q_EMIT filedialogPreviewChanged();
    }
}

const bool PQCSettings::getDefaultForFiledialogPreview() const {
        return false;
}

void PQCSettings::setDefaultForFiledialogPreview() {
    if(false != m_filedialogPreview) {
        m_filedialogPreview = false;
        Q_EMIT filedialogPreviewChanged();
    }
}

bool PQCSettings::getFiledialogPreviewBlur() const {
    return m_filedialogPreviewBlur;
}

void PQCSettings::setFiledialogPreviewBlur(const bool val) {
    if(val != m_filedialogPreviewBlur) {
        m_filedialogPreviewBlur = val;
        Q_EMIT filedialogPreviewBlurChanged();
    }
}

const bool PQCSettings::getDefaultForFiledialogPreviewBlur() const {
        return false;
}

void PQCSettings::setDefaultForFiledialogPreviewBlur() {
    if(false != m_filedialogPreviewBlur) {
        m_filedialogPreviewBlur = false;
        Q_EMIT filedialogPreviewBlurChanged();
    }
}

int PQCSettings::getFiledialogPreviewColorIntensity() const {
    return m_filedialogPreviewColorIntensity;
}

void PQCSettings::setFiledialogPreviewColorIntensity(const int val) {
    if(val != m_filedialogPreviewColorIntensity) {
        m_filedialogPreviewColorIntensity = val;
        Q_EMIT filedialogPreviewColorIntensityChanged();
    }
}

const int PQCSettings::getDefaultForFiledialogPreviewColorIntensity() const {
        return 50;
}

void PQCSettings::setDefaultForFiledialogPreviewColorIntensity() {
    if(50 != m_filedialogPreviewColorIntensity) {
        m_filedialogPreviewColorIntensity = 50;
    }
}

bool PQCSettings::getFiledialogPreviewCropToFit() const {
    return m_filedialogPreviewCropToFit;
}

void PQCSettings::setFiledialogPreviewCropToFit(const bool val) {
    if(val != m_filedialogPreviewCropToFit) {
        m_filedialogPreviewCropToFit = val;
        Q_EMIT filedialogPreviewCropToFitChanged();
    }
}

const bool PQCSettings::getDefaultForFiledialogPreviewCropToFit() const {
        return true;
}

void PQCSettings::setDefaultForFiledialogPreviewCropToFit() {
    if(true != m_filedialogPreviewCropToFit) {
        m_filedialogPreviewCropToFit = true;
        Q_EMIT filedialogPreviewCropToFitChanged();
    }
}

bool PQCSettings::getFiledialogPreviewHigherResolution() const {
    return m_filedialogPreviewHigherResolution;
}

void PQCSettings::setFiledialogPreviewHigherResolution(const bool val) {
    if(val != m_filedialogPreviewHigherResolution) {
        m_filedialogPreviewHigherResolution = val;
        Q_EMIT filedialogPreviewHigherResolutionChanged();
    }
}

const bool PQCSettings::getDefaultForFiledialogPreviewHigherResolution() const {
        return false;
}

void PQCSettings::setDefaultForFiledialogPreviewHigherResolution() {
    if(false != m_filedialogPreviewHigherResolution) {
        m_filedialogPreviewHigherResolution = false;
        Q_EMIT filedialogPreviewHigherResolutionChanged();
    }
}

bool PQCSettings::getFiledialogPreviewMuted() const {
    return m_filedialogPreviewMuted;
}

void PQCSettings::setFiledialogPreviewMuted(const bool val) {
    if(val != m_filedialogPreviewMuted) {
        m_filedialogPreviewMuted = val;
        Q_EMIT filedialogPreviewMutedChanged();
    }
}

const bool PQCSettings::getDefaultForFiledialogPreviewMuted() const {
        return false;
}

void PQCSettings::setDefaultForFiledialogPreviewMuted() {
    if(false != m_filedialogPreviewMuted) {
        m_filedialogPreviewMuted = false;
        Q_EMIT filedialogPreviewMutedChanged();
    }
}

bool PQCSettings::getFiledialogRememberSelection() const {
    return m_filedialogRememberSelection;
}

void PQCSettings::setFiledialogRememberSelection(const bool val) {
    if(val != m_filedialogRememberSelection) {
        m_filedialogRememberSelection = val;
        Q_EMIT filedialogRememberSelectionChanged();
    }
}

const bool PQCSettings::getDefaultForFiledialogRememberSelection() const {
        return false;
}

void PQCSettings::setDefaultForFiledialogRememberSelection() {
    if(false != m_filedialogRememberSelection) {
        m_filedialogRememberSelection = false;
        Q_EMIT filedialogRememberSelectionChanged();
    }
}

bool PQCSettings::getFiledialogShowHiddenFilesFolders() const {
    return m_filedialogShowHiddenFilesFolders;
}

void PQCSettings::setFiledialogShowHiddenFilesFolders(const bool val) {
    if(val != m_filedialogShowHiddenFilesFolders) {
        m_filedialogShowHiddenFilesFolders = val;
        Q_EMIT filedialogShowHiddenFilesFoldersChanged();
    }
}

const bool PQCSettings::getDefaultForFiledialogShowHiddenFilesFolders() const {
        return false;
}

void PQCSettings::setDefaultForFiledialogShowHiddenFilesFolders() {
    if(false != m_filedialogShowHiddenFilesFolders) {
        m_filedialogShowHiddenFilesFolders = false;
        Q_EMIT filedialogShowHiddenFilesFoldersChanged();
    }
}

bool PQCSettings::getFiledialogSingleClickSelect() const {
    return m_filedialogSingleClickSelect;
}

void PQCSettings::setFiledialogSingleClickSelect(const bool val) {
    if(val != m_filedialogSingleClickSelect) {
        m_filedialogSingleClickSelect = val;
        Q_EMIT filedialogSingleClickSelectChanged();
    }
}

const bool PQCSettings::getDefaultForFiledialogSingleClickSelect() const {
        return false;
}

void PQCSettings::setDefaultForFiledialogSingleClickSelect() {
    if(false != m_filedialogSingleClickSelect) {
        m_filedialogSingleClickSelect = false;
        Q_EMIT filedialogSingleClickSelectChanged();
    }
}

bool PQCSettings::getFiledialogStartupRestoreCustom() const {
    return m_filedialogStartupRestoreCustom;
}

void PQCSettings::setFiledialogStartupRestoreCustom(const bool val) {
    if(val != m_filedialogStartupRestoreCustom) {
        m_filedialogStartupRestoreCustom = val;
        Q_EMIT filedialogStartupRestoreCustomChanged();
    }
}

const bool PQCSettings::getDefaultForFiledialogStartupRestoreCustom() const {
        return false;
}

void PQCSettings::setDefaultForFiledialogStartupRestoreCustom() {
    if(false != m_filedialogStartupRestoreCustom) {
        m_filedialogStartupRestoreCustom = false;
        Q_EMIT filedialogStartupRestoreCustomChanged();
    }
}

QString PQCSettings::getFiledialogStartupRestoreCustomFolder() const {
    return m_filedialogStartupRestoreCustomFolder;
}

void PQCSettings::setFiledialogStartupRestoreCustomFolder(const QString val) {
    if(val != m_filedialogStartupRestoreCustomFolder) {
        m_filedialogStartupRestoreCustomFolder = val;
        Q_EMIT filedialogStartupRestoreCustomFolderChanged();
    }
}

const QString PQCSettings::getDefaultForFiledialogStartupRestoreCustomFolder() const {
        return "";
}

void PQCSettings::setDefaultForFiledialogStartupRestoreCustomFolder() {
    if("" != m_filedialogStartupRestoreCustomFolder) {
        m_filedialogStartupRestoreCustomFolder = "";
        Q_EMIT filedialogStartupRestoreCustomFolderChanged();
    }
}

bool PQCSettings::getFiledialogStartupRestoreHome() const {
    return m_filedialogStartupRestoreHome;
}

void PQCSettings::setFiledialogStartupRestoreHome(const bool val) {
    if(val != m_filedialogStartupRestoreHome) {
        m_filedialogStartupRestoreHome = val;
        Q_EMIT filedialogStartupRestoreHomeChanged();
    }
}

const bool PQCSettings::getDefaultForFiledialogStartupRestoreHome() const {
        return false;
}

void PQCSettings::setDefaultForFiledialogStartupRestoreHome() {
    if(false != m_filedialogStartupRestoreHome) {
        m_filedialogStartupRestoreHome = false;
        Q_EMIT filedialogStartupRestoreHomeChanged();
    }
}

bool PQCSettings::getFiledialogStartupRestorePrevious() const {
    return m_filedialogStartupRestorePrevious;
}

void PQCSettings::setFiledialogStartupRestorePrevious(const bool val) {
    if(val != m_filedialogStartupRestorePrevious) {
        m_filedialogStartupRestorePrevious = val;
        Q_EMIT filedialogStartupRestorePreviousChanged();
    }
}

const bool PQCSettings::getDefaultForFiledialogStartupRestorePrevious() const {
        return true;
}

void PQCSettings::setDefaultForFiledialogStartupRestorePrevious() {
    if(true != m_filedialogStartupRestorePrevious) {
        m_filedialogStartupRestorePrevious = true;
        Q_EMIT filedialogStartupRestorePreviousChanged();
    }
}

bool PQCSettings::getFiledialogThumbnailSizeFollowsGlobalThumbnails() const {
    return m_filedialogThumbnailSizeFollowsGlobalThumbnails;
}

void PQCSettings::setFiledialogThumbnailSizeFollowsGlobalThumbnails(const bool val) {
    if(val != m_filedialogThumbnailSizeFollowsGlobalThumbnails) {
        m_filedialogThumbnailSizeFollowsGlobalThumbnails = val;
        Q_EMIT filedialogThumbnailSizeFollowsGlobalThumbnailsChanged();
    }
}

const bool PQCSettings::getDefaultForFiledialogThumbnailSizeFollowsGlobalThumbnails() const {
        return true;
}

void PQCSettings::setDefaultForFiledialogThumbnailSizeFollowsGlobalThumbnails() {
    if(true != m_filedialogThumbnailSizeFollowsGlobalThumbnails) {
        m_filedialogThumbnailSizeFollowsGlobalThumbnails = true;
        Q_EMIT filedialogThumbnailSizeFollowsGlobalThumbnailsChanged();
    }
}

bool PQCSettings::getFiledialogThumbnails() const {
    return m_filedialogThumbnails;
}

void PQCSettings::setFiledialogThumbnails(const bool val) {
    if(val != m_filedialogThumbnails) {
        m_filedialogThumbnails = val;
        Q_EMIT filedialogThumbnailsChanged();
    }
}

const bool PQCSettings::getDefaultForFiledialogThumbnails() const {
        return true;
}

void PQCSettings::setDefaultForFiledialogThumbnails() {
    if(true != m_filedialogThumbnails) {
        m_filedialogThumbnails = true;
        Q_EMIT filedialogThumbnailsChanged();
    }
}

bool PQCSettings::getFiledialogThumbnailsScaleCrop() const {
    return m_filedialogThumbnailsScaleCrop;
}

void PQCSettings::setFiledialogThumbnailsScaleCrop(const bool val) {
    if(val != m_filedialogThumbnailsScaleCrop) {
        m_filedialogThumbnailsScaleCrop = val;
        Q_EMIT filedialogThumbnailsScaleCropChanged();
    }
}

const bool PQCSettings::getDefaultForFiledialogThumbnailsScaleCrop() const {
        return true;
}

void PQCSettings::setDefaultForFiledialogThumbnailsScaleCrop() {
    if(true != m_filedialogThumbnailsScaleCrop) {
        m_filedialogThumbnailsScaleCrop = true;
        Q_EMIT filedialogThumbnailsScaleCropChanged();
    }
}

bool PQCSettings::getFiledialogUseNativeFileDialog() const {
    return m_filedialogUseNativeFileDialog;
}

void PQCSettings::setFiledialogUseNativeFileDialog(const bool val) {
    if(val != m_filedialogUseNativeFileDialog) {
        m_filedialogUseNativeFileDialog = val;
        Q_EMIT filedialogUseNativeFileDialogChanged();
    }
}

const bool PQCSettings::getDefaultForFiledialogUseNativeFileDialog() const {
        return false;
}

void PQCSettings::setDefaultForFiledialogUseNativeFileDialog() {
    if(false != m_filedialogUseNativeFileDialog) {
        m_filedialogUseNativeFileDialog = false;
        Q_EMIT filedialogUseNativeFileDialogChanged();
    }
}

int PQCSettings::getFiledialogZoom() const {
    return m_filedialogZoom;
}

void PQCSettings::setFiledialogZoom(const int val) {
    if(val != m_filedialogZoom) {
        m_filedialogZoom = val;
        Q_EMIT filedialogZoomChanged();
    }
}

const int PQCSettings::getDefaultForFiledialogZoom() const {
        return 12;
}

void PQCSettings::setDefaultForFiledialogZoom() {
    if(12 != m_filedialogZoom) {
        m_filedialogZoom = 12;
    }
}

bool PQCSettings::getFiletypesAnimatedControls() const {
    return m_filetypesAnimatedControls;
}

void PQCSettings::setFiletypesAnimatedControls(const bool val) {
    if(val != m_filetypesAnimatedControls) {
        m_filetypesAnimatedControls = val;
        Q_EMIT filetypesAnimatedControlsChanged();
    }
}

const bool PQCSettings::getDefaultForFiletypesAnimatedControls() const {
        return true;
}

void PQCSettings::setDefaultForFiletypesAnimatedControls() {
    if(true != m_filetypesAnimatedControls) {
        m_filetypesAnimatedControls = true;
        Q_EMIT filetypesAnimatedControlsChanged();
    }
}

bool PQCSettings::getFiletypesAnimatedLeftRight() const {
    return m_filetypesAnimatedLeftRight;
}

void PQCSettings::setFiletypesAnimatedLeftRight(const bool val) {
    if(val != m_filetypesAnimatedLeftRight) {
        m_filetypesAnimatedLeftRight = val;
        Q_EMIT filetypesAnimatedLeftRightChanged();
    }
}

const bool PQCSettings::getDefaultForFiletypesAnimatedLeftRight() const {
        return false;
}

void PQCSettings::setDefaultForFiletypesAnimatedLeftRight() {
    if(false != m_filetypesAnimatedLeftRight) {
        m_filetypesAnimatedLeftRight = false;
        Q_EMIT filetypesAnimatedLeftRightChanged();
    }
}

bool PQCSettings::getFiletypesAnimatedSpacePause() const {
    return m_filetypesAnimatedSpacePause;
}

void PQCSettings::setFiletypesAnimatedSpacePause(const bool val) {
    if(val != m_filetypesAnimatedSpacePause) {
        m_filetypesAnimatedSpacePause = val;
        Q_EMIT filetypesAnimatedSpacePauseChanged();
    }
}

const bool PQCSettings::getDefaultForFiletypesAnimatedSpacePause() const {
        return true;
}

void PQCSettings::setDefaultForFiletypesAnimatedSpacePause() {
    if(true != m_filetypesAnimatedSpacePause) {
        m_filetypesAnimatedSpacePause = true;
        Q_EMIT filetypesAnimatedSpacePauseChanged();
    }
}

bool PQCSettings::getFiletypesArchiveAlwaysEnterAutomatically() const {
    return m_filetypesArchiveAlwaysEnterAutomatically;
}

void PQCSettings::setFiletypesArchiveAlwaysEnterAutomatically(const bool val) {
    if(val != m_filetypesArchiveAlwaysEnterAutomatically) {
        m_filetypesArchiveAlwaysEnterAutomatically = val;
        Q_EMIT filetypesArchiveAlwaysEnterAutomaticallyChanged();
    }
}

const bool PQCSettings::getDefaultForFiletypesArchiveAlwaysEnterAutomatically() const {
        return false;
}

void PQCSettings::setDefaultForFiletypesArchiveAlwaysEnterAutomatically() {
    if(false != m_filetypesArchiveAlwaysEnterAutomatically) {
        m_filetypesArchiveAlwaysEnterAutomatically = false;
        Q_EMIT filetypesArchiveAlwaysEnterAutomaticallyChanged();
    }
}

bool PQCSettings::getFiletypesArchiveControls() const {
    return m_filetypesArchiveControls;
}

void PQCSettings::setFiletypesArchiveControls(const bool val) {
    if(val != m_filetypesArchiveControls) {
        m_filetypesArchiveControls = val;
        Q_EMIT filetypesArchiveControlsChanged();
    }
}

const bool PQCSettings::getDefaultForFiletypesArchiveControls() const {
        return true;
}

void PQCSettings::setDefaultForFiletypesArchiveControls() {
    if(true != m_filetypesArchiveControls) {
        m_filetypesArchiveControls = true;
        Q_EMIT filetypesArchiveControlsChanged();
    }
}

bool PQCSettings::getFiletypesArchiveDontLoadMoreFilesThan() const {
    return m_filetypesArchiveDontLoadMoreFilesThan;
}

void PQCSettings::setFiletypesArchiveDontLoadMoreFilesThan(const bool val) {
    if(val != m_filetypesArchiveDontLoadMoreFilesThan) {
        m_filetypesArchiveDontLoadMoreFilesThan = val;
        Q_EMIT filetypesArchiveDontLoadMoreFilesThanChanged();
    }
}

const bool PQCSettings::getDefaultForFiletypesArchiveDontLoadMoreFilesThan() const {
        return false;
}

void PQCSettings::setDefaultForFiletypesArchiveDontLoadMoreFilesThan() {
    if(false != m_filetypesArchiveDontLoadMoreFilesThan) {
        m_filetypesArchiveDontLoadMoreFilesThan = false;
        Q_EMIT filetypesArchiveDontLoadMoreFilesThanChanged();
    }
}

int PQCSettings::getFiletypesArchiveDontLoadMoreFilesThanCount() const {
    return m_filetypesArchiveDontLoadMoreFilesThanCount;
}

void PQCSettings::setFiletypesArchiveDontLoadMoreFilesThanCount(const int val) {
    if(val != m_filetypesArchiveDontLoadMoreFilesThanCount) {
        m_filetypesArchiveDontLoadMoreFilesThanCount = val;
        Q_EMIT filetypesArchiveDontLoadMoreFilesThanCountChanged();
    }
}

const int PQCSettings::getDefaultForFiletypesArchiveDontLoadMoreFilesThanCount() const {
        return 2000;
}

void PQCSettings::setDefaultForFiletypesArchiveDontLoadMoreFilesThanCount() {
    if(2000 != m_filetypesArchiveDontLoadMoreFilesThanCount) {
        m_filetypesArchiveDontLoadMoreFilesThanCount = 2000;
    }
}

bool PQCSettings::getFiletypesArchiveIgnoreLargerThan() const {
    return m_filetypesArchiveIgnoreLargerThan;
}

void PQCSettings::setFiletypesArchiveIgnoreLargerThan(const bool val) {
    if(val != m_filetypesArchiveIgnoreLargerThan) {
        m_filetypesArchiveIgnoreLargerThan = val;
        Q_EMIT filetypesArchiveIgnoreLargerThanChanged();
    }
}

const bool PQCSettings::getDefaultForFiletypesArchiveIgnoreLargerThan() const {
        return false;
}

void PQCSettings::setDefaultForFiletypesArchiveIgnoreLargerThan() {
    if(false != m_filetypesArchiveIgnoreLargerThan) {
        m_filetypesArchiveIgnoreLargerThan = false;
        Q_EMIT filetypesArchiveIgnoreLargerThanChanged();
    }
}

int PQCSettings::getFiletypesArchiveIgnoreLargerThanSize() const {
    return m_filetypesArchiveIgnoreLargerThanSize;
}

void PQCSettings::setFiletypesArchiveIgnoreLargerThanSize(const int val) {
    if(val != m_filetypesArchiveIgnoreLargerThanSize) {
        m_filetypesArchiveIgnoreLargerThanSize = val;
        Q_EMIT filetypesArchiveIgnoreLargerThanSizeChanged();
    }
}

const int PQCSettings::getDefaultForFiletypesArchiveIgnoreLargerThanSize() const {
        return 2048;
}

void PQCSettings::setDefaultForFiletypesArchiveIgnoreLargerThanSize() {
    if(2048 != m_filetypesArchiveIgnoreLargerThanSize) {
        m_filetypesArchiveIgnoreLargerThanSize = 2048;
    }
}

bool PQCSettings::getFiletypesArchiveLeftRight() const {
    return m_filetypesArchiveLeftRight;
}

void PQCSettings::setFiletypesArchiveLeftRight(const bool val) {
    if(val != m_filetypesArchiveLeftRight) {
        m_filetypesArchiveLeftRight = val;
        Q_EMIT filetypesArchiveLeftRightChanged();
    }
}

const bool PQCSettings::getDefaultForFiletypesArchiveLeftRight() const {
        return false;
}

void PQCSettings::setDefaultForFiletypesArchiveLeftRight() {
    if(false != m_filetypesArchiveLeftRight) {
        m_filetypesArchiveLeftRight = false;
        Q_EMIT filetypesArchiveLeftRightChanged();
    }
}

bool PQCSettings::getFiletypesArchiveViewerModeExitButton() const {
    return m_filetypesArchiveViewerModeExitButton;
}

void PQCSettings::setFiletypesArchiveViewerModeExitButton(const bool val) {
    if(val != m_filetypesArchiveViewerModeExitButton) {
        m_filetypesArchiveViewerModeExitButton = val;
        Q_EMIT filetypesArchiveViewerModeExitButtonChanged();
    }
}

const bool PQCSettings::getDefaultForFiletypesArchiveViewerModeExitButton() const {
        return true;
}

void PQCSettings::setDefaultForFiletypesArchiveViewerModeExitButton() {
    if(true != m_filetypesArchiveViewerModeExitButton) {
        m_filetypesArchiveViewerModeExitButton = true;
        Q_EMIT filetypesArchiveViewerModeExitButtonChanged();
    }
}

bool PQCSettings::getFiletypesComicBookAlwaysEnterAutomatically() const {
    return m_filetypesComicBookAlwaysEnterAutomatically;
}

void PQCSettings::setFiletypesComicBookAlwaysEnterAutomatically(const bool val) {
    if(val != m_filetypesComicBookAlwaysEnterAutomatically) {
        m_filetypesComicBookAlwaysEnterAutomatically = val;
        Q_EMIT filetypesComicBookAlwaysEnterAutomaticallyChanged();
    }
}

const bool PQCSettings::getDefaultForFiletypesComicBookAlwaysEnterAutomatically() const {
        return false;
}

void PQCSettings::setDefaultForFiletypesComicBookAlwaysEnterAutomatically() {
    if(false != m_filetypesComicBookAlwaysEnterAutomatically) {
        m_filetypesComicBookAlwaysEnterAutomatically = false;
        Q_EMIT filetypesComicBookAlwaysEnterAutomaticallyChanged();
    }
}

bool PQCSettings::getFiletypesDocumentAlwaysEnterAutomatically() const {
    return m_filetypesDocumentAlwaysEnterAutomatically;
}

void PQCSettings::setFiletypesDocumentAlwaysEnterAutomatically(const bool val) {
    if(val != m_filetypesDocumentAlwaysEnterAutomatically) {
        m_filetypesDocumentAlwaysEnterAutomatically = val;
        Q_EMIT filetypesDocumentAlwaysEnterAutomaticallyChanged();
    }
}

const bool PQCSettings::getDefaultForFiletypesDocumentAlwaysEnterAutomatically() const {
        return false;
}

void PQCSettings::setDefaultForFiletypesDocumentAlwaysEnterAutomatically() {
    if(false != m_filetypesDocumentAlwaysEnterAutomatically) {
        m_filetypesDocumentAlwaysEnterAutomatically = false;
        Q_EMIT filetypesDocumentAlwaysEnterAutomaticallyChanged();
    }
}

bool PQCSettings::getFiletypesDocumentControls() const {
    return m_filetypesDocumentControls;
}

void PQCSettings::setFiletypesDocumentControls(const bool val) {
    if(val != m_filetypesDocumentControls) {
        m_filetypesDocumentControls = val;
        Q_EMIT filetypesDocumentControlsChanged();
    }
}

const bool PQCSettings::getDefaultForFiletypesDocumentControls() const {
        return true;
}

void PQCSettings::setDefaultForFiletypesDocumentControls() {
    if(true != m_filetypesDocumentControls) {
        m_filetypesDocumentControls = true;
        Q_EMIT filetypesDocumentControlsChanged();
    }
}

bool PQCSettings::getFiletypesDocumentLeftRight() const {
    return m_filetypesDocumentLeftRight;
}

void PQCSettings::setFiletypesDocumentLeftRight(const bool val) {
    if(val != m_filetypesDocumentLeftRight) {
        m_filetypesDocumentLeftRight = val;
        Q_EMIT filetypesDocumentLeftRightChanged();
    }
}

const bool PQCSettings::getDefaultForFiletypesDocumentLeftRight() const {
        return false;
}

void PQCSettings::setDefaultForFiletypesDocumentLeftRight() {
    if(false != m_filetypesDocumentLeftRight) {
        m_filetypesDocumentLeftRight = false;
        Q_EMIT filetypesDocumentLeftRightChanged();
    }
}

bool PQCSettings::getFiletypesDocumentViewerModeExitButton() const {
    return m_filetypesDocumentViewerModeExitButton;
}

void PQCSettings::setFiletypesDocumentViewerModeExitButton(const bool val) {
    if(val != m_filetypesDocumentViewerModeExitButton) {
        m_filetypesDocumentViewerModeExitButton = val;
        Q_EMIT filetypesDocumentViewerModeExitButtonChanged();
    }
}

const bool PQCSettings::getDefaultForFiletypesDocumentViewerModeExitButton() const {
        return true;
}

void PQCSettings::setDefaultForFiletypesDocumentViewerModeExitButton() {
    if(true != m_filetypesDocumentViewerModeExitButton) {
        m_filetypesDocumentViewerModeExitButton = true;
        Q_EMIT filetypesDocumentViewerModeExitButtonChanged();
    }
}

bool PQCSettings::getFiletypesExternalUnrar() const {
    return m_filetypesExternalUnrar;
}

void PQCSettings::setFiletypesExternalUnrar(const bool val) {
    if(val != m_filetypesExternalUnrar) {
        m_filetypesExternalUnrar = val;
        Q_EMIT filetypesExternalUnrarChanged();
    }
}

const bool PQCSettings::getDefaultForFiletypesExternalUnrar() const {
        return false;
}

void PQCSettings::setDefaultForFiletypesExternalUnrar() {
    if(false != m_filetypesExternalUnrar) {
        m_filetypesExternalUnrar = false;
        Q_EMIT filetypesExternalUnrarChanged();
    }
}

bool PQCSettings::getFiletypesLoadAppleLivePhotos() const {
    return m_filetypesLoadAppleLivePhotos;
}

void PQCSettings::setFiletypesLoadAppleLivePhotos(const bool val) {
    if(val != m_filetypesLoadAppleLivePhotos) {
        m_filetypesLoadAppleLivePhotos = val;
        Q_EMIT filetypesLoadAppleLivePhotosChanged();
    }
}

const bool PQCSettings::getDefaultForFiletypesLoadAppleLivePhotos() const {
        return true;
}

void PQCSettings::setDefaultForFiletypesLoadAppleLivePhotos() {
    if(true != m_filetypesLoadAppleLivePhotos) {
        m_filetypesLoadAppleLivePhotos = true;
        Q_EMIT filetypesLoadAppleLivePhotosChanged();
    }
}

bool PQCSettings::getFiletypesLoadMotionPhotos() const {
    return m_filetypesLoadMotionPhotos;
}

void PQCSettings::setFiletypesLoadMotionPhotos(const bool val) {
    if(val != m_filetypesLoadMotionPhotos) {
        m_filetypesLoadMotionPhotos = val;
        Q_EMIT filetypesLoadMotionPhotosChanged();
    }
}

const bool PQCSettings::getDefaultForFiletypesLoadMotionPhotos() const {
        return true;
}

void PQCSettings::setDefaultForFiletypesLoadMotionPhotos() {
    if(true != m_filetypesLoadMotionPhotos) {
        m_filetypesLoadMotionPhotos = true;
        Q_EMIT filetypesLoadMotionPhotosChanged();
    }
}

bool PQCSettings::getFiletypesMotionAutoPlay() const {
    return m_filetypesMotionAutoPlay;
}

void PQCSettings::setFiletypesMotionAutoPlay(const bool val) {
    if(val != m_filetypesMotionAutoPlay) {
        m_filetypesMotionAutoPlay = val;
        Q_EMIT filetypesMotionAutoPlayChanged();
    }
}

const bool PQCSettings::getDefaultForFiletypesMotionAutoPlay() const {
        return true;
}

void PQCSettings::setDefaultForFiletypesMotionAutoPlay() {
    if(true != m_filetypesMotionAutoPlay) {
        m_filetypesMotionAutoPlay = true;
        Q_EMIT filetypesMotionAutoPlayChanged();
    }
}

bool PQCSettings::getFiletypesMotionPhotoPlayPause() const {
    return m_filetypesMotionPhotoPlayPause;
}

void PQCSettings::setFiletypesMotionPhotoPlayPause(const bool val) {
    if(val != m_filetypesMotionPhotoPlayPause) {
        m_filetypesMotionPhotoPlayPause = val;
        Q_EMIT filetypesMotionPhotoPlayPauseChanged();
    }
}

const bool PQCSettings::getDefaultForFiletypesMotionPhotoPlayPause() const {
        return true;
}

void PQCSettings::setDefaultForFiletypesMotionPhotoPlayPause() {
    if(true != m_filetypesMotionPhotoPlayPause) {
        m_filetypesMotionPhotoPlayPause = true;
        Q_EMIT filetypesMotionPhotoPlayPauseChanged();
    }
}

bool PQCSettings::getFiletypesMotionSpacePause() const {
    return m_filetypesMotionSpacePause;
}

void PQCSettings::setFiletypesMotionSpacePause(const bool val) {
    if(val != m_filetypesMotionSpacePause) {
        m_filetypesMotionSpacePause = val;
        Q_EMIT filetypesMotionSpacePauseChanged();
    }
}

const bool PQCSettings::getDefaultForFiletypesMotionSpacePause() const {
        return true;
}

void PQCSettings::setDefaultForFiletypesMotionSpacePause() {
    if(true != m_filetypesMotionSpacePause) {
        m_filetypesMotionSpacePause = true;
        Q_EMIT filetypesMotionSpacePauseChanged();
    }
}

int PQCSettings::getFiletypesPDFQuality() const {
    return m_filetypesPDFQuality;
}

void PQCSettings::setFiletypesPDFQuality(const int val) {
    if(val != m_filetypesPDFQuality) {
        m_filetypesPDFQuality = val;
        Q_EMIT filetypesPDFQualityChanged();
    }
}

const int PQCSettings::getDefaultForFiletypesPDFQuality() const {
        return 150;
}

void PQCSettings::setDefaultForFiletypesPDFQuality() {
    if(150 != m_filetypesPDFQuality) {
        m_filetypesPDFQuality = 150;
    }
}

bool PQCSettings::getFiletypesPhotoSphereArrowKeys() const {
    return m_filetypesPhotoSphereArrowKeys;
}

void PQCSettings::setFiletypesPhotoSphereArrowKeys(const bool val) {
    if(val != m_filetypesPhotoSphereArrowKeys) {
        m_filetypesPhotoSphereArrowKeys = val;
        Q_EMIT filetypesPhotoSphereArrowKeysChanged();
    }
}

const bool PQCSettings::getDefaultForFiletypesPhotoSphereArrowKeys() const {
        return false;
}

void PQCSettings::setDefaultForFiletypesPhotoSphereArrowKeys() {
    if(false != m_filetypesPhotoSphereArrowKeys) {
        m_filetypesPhotoSphereArrowKeys = false;
        Q_EMIT filetypesPhotoSphereArrowKeysChanged();
    }
}

bool PQCSettings::getFiletypesPhotoSphereAutoLoad() const {
    return m_filetypesPhotoSphereAutoLoad;
}

void PQCSettings::setFiletypesPhotoSphereAutoLoad(const bool val) {
    if(val != m_filetypesPhotoSphereAutoLoad) {
        m_filetypesPhotoSphereAutoLoad = val;
        Q_EMIT filetypesPhotoSphereAutoLoadChanged();
    }
}

const bool PQCSettings::getDefaultForFiletypesPhotoSphereAutoLoad() const {
        return true;
}

void PQCSettings::setDefaultForFiletypesPhotoSphereAutoLoad() {
    if(true != m_filetypesPhotoSphereAutoLoad) {
        m_filetypesPhotoSphereAutoLoad = true;
        Q_EMIT filetypesPhotoSphereAutoLoadChanged();
    }
}

bool PQCSettings::getFiletypesPhotoSphereBigButton() const {
    return m_filetypesPhotoSphereBigButton;
}

void PQCSettings::setFiletypesPhotoSphereBigButton(const bool val) {
    if(val != m_filetypesPhotoSphereBigButton) {
        m_filetypesPhotoSphereBigButton = val;
        Q_EMIT filetypesPhotoSphereBigButtonChanged();
    }
}

const bool PQCSettings::getDefaultForFiletypesPhotoSphereBigButton() const {
        return false;
}

void PQCSettings::setDefaultForFiletypesPhotoSphereBigButton() {
    if(false != m_filetypesPhotoSphereBigButton) {
        m_filetypesPhotoSphereBigButton = false;
        Q_EMIT filetypesPhotoSphereBigButtonChanged();
    }
}

bool PQCSettings::getFiletypesPhotoSphereControls() const {
    return m_filetypesPhotoSphereControls;
}

void PQCSettings::setFiletypesPhotoSphereControls(const bool val) {
    if(val != m_filetypesPhotoSphereControls) {
        m_filetypesPhotoSphereControls = val;
        Q_EMIT filetypesPhotoSphereControlsChanged();
    }
}

const bool PQCSettings::getDefaultForFiletypesPhotoSphereControls() const {
        return false;
}

void PQCSettings::setDefaultForFiletypesPhotoSphereControls() {
    if(false != m_filetypesPhotoSphereControls) {
        m_filetypesPhotoSphereControls = false;
        Q_EMIT filetypesPhotoSphereControlsChanged();
    }
}

bool PQCSettings::getFiletypesPhotoSpherePanOnLoad() const {
    return m_filetypesPhotoSpherePanOnLoad;
}

void PQCSettings::setFiletypesPhotoSpherePanOnLoad(const bool val) {
    if(val != m_filetypesPhotoSpherePanOnLoad) {
        m_filetypesPhotoSpherePanOnLoad = val;
        Q_EMIT filetypesPhotoSpherePanOnLoadChanged();
    }
}

const bool PQCSettings::getDefaultForFiletypesPhotoSpherePanOnLoad() const {
        return true;
}

void PQCSettings::setDefaultForFiletypesPhotoSpherePanOnLoad() {
    if(true != m_filetypesPhotoSpherePanOnLoad) {
        m_filetypesPhotoSpherePanOnLoad = true;
        Q_EMIT filetypesPhotoSpherePanOnLoadChanged();
    }
}

bool PQCSettings::getFiletypesRAWUseEmbeddedIfAvailable() const {
    return m_filetypesRAWUseEmbeddedIfAvailable;
}

void PQCSettings::setFiletypesRAWUseEmbeddedIfAvailable(const bool val) {
    if(val != m_filetypesRAWUseEmbeddedIfAvailable) {
        m_filetypesRAWUseEmbeddedIfAvailable = val;
        Q_EMIT filetypesRAWUseEmbeddedIfAvailableChanged();
    }
}

const bool PQCSettings::getDefaultForFiletypesRAWUseEmbeddedIfAvailable() const {
        return true;
}

void PQCSettings::setDefaultForFiletypesRAWUseEmbeddedIfAvailable() {
    if(true != m_filetypesRAWUseEmbeddedIfAvailable) {
        m_filetypesRAWUseEmbeddedIfAvailable = true;
        Q_EMIT filetypesRAWUseEmbeddedIfAvailableChanged();
    }
}

bool PQCSettings::getFiletypesVideoAutoplay() const {
    return m_filetypesVideoAutoplay;
}

void PQCSettings::setFiletypesVideoAutoplay(const bool val) {
    if(val != m_filetypesVideoAutoplay) {
        m_filetypesVideoAutoplay = val;
        Q_EMIT filetypesVideoAutoplayChanged();
    }
}

const bool PQCSettings::getDefaultForFiletypesVideoAutoplay() const {
        return true;
}

void PQCSettings::setDefaultForFiletypesVideoAutoplay() {
    if(true != m_filetypesVideoAutoplay) {
        m_filetypesVideoAutoplay = true;
        Q_EMIT filetypesVideoAutoplayChanged();
    }
}

QStringList PQCSettings::getFiletypesVideoBackend() const {
    return m_filetypesVideoBackend;
}

void PQCSettings::setFiletypesVideoBackend(const QStringList val) {
    if(val != m_filetypesVideoBackend) {
        m_filetypesVideoBackend = val;
        Q_EMIT filetypesVideoBackendChanged();
    }
}

const QStringList PQCSettings::getDefaultForFiletypesVideoBackend() const {
        return QStringList() << "qt" << "mpv";
}

void PQCSettings::setDefaultForFiletypesVideoBackend() {
    QStringList tmp = QStringList() << "qt" << "mpv";
    if(tmp != m_filetypesVideoBackend) {
        m_filetypesVideoBackend = tmp;
        Q_EMIT filetypesVideoBackendChanged();
    }
}

bool PQCSettings::getFiletypesVideoLeftRightJumpVideo() const {
    return m_filetypesVideoLeftRightJumpVideo;
}

void PQCSettings::setFiletypesVideoLeftRightJumpVideo(const bool val) {
    if(val != m_filetypesVideoLeftRightJumpVideo) {
        m_filetypesVideoLeftRightJumpVideo = val;
        Q_EMIT filetypesVideoLeftRightJumpVideoChanged();
    }
}

const bool PQCSettings::getDefaultForFiletypesVideoLeftRightJumpVideo() const {
        return false;
}

void PQCSettings::setDefaultForFiletypesVideoLeftRightJumpVideo() {
    if(false != m_filetypesVideoLeftRightJumpVideo) {
        m_filetypesVideoLeftRightJumpVideo = false;
        Q_EMIT filetypesVideoLeftRightJumpVideoChanged();
    }
}

bool PQCSettings::getFiletypesVideoLoop() const {
    return m_filetypesVideoLoop;
}

void PQCSettings::setFiletypesVideoLoop(const bool val) {
    if(val != m_filetypesVideoLoop) {
        m_filetypesVideoLoop = val;
        Q_EMIT filetypesVideoLoopChanged();
    }
}

const bool PQCSettings::getDefaultForFiletypesVideoLoop() const {
        return false;
}

void PQCSettings::setDefaultForFiletypesVideoLoop() {
    if(false != m_filetypesVideoLoop) {
        m_filetypesVideoLoop = false;
        Q_EMIT filetypesVideoLoopChanged();
    }
}

bool PQCSettings::getFiletypesVideoSpacePause() const {
    return m_filetypesVideoSpacePause;
}

void PQCSettings::setFiletypesVideoSpacePause(const bool val) {
    if(val != m_filetypesVideoSpacePause) {
        m_filetypesVideoSpacePause = val;
        Q_EMIT filetypesVideoSpacePauseChanged();
    }
}

const bool PQCSettings::getDefaultForFiletypesVideoSpacePause() const {
        return true;
}

void PQCSettings::setDefaultForFiletypesVideoSpacePause() {
    if(true != m_filetypesVideoSpacePause) {
        m_filetypesVideoSpacePause = true;
        Q_EMIT filetypesVideoSpacePauseChanged();
    }
}

QString PQCSettings::getFiletypesVideoThumbnailer() const {
    return m_filetypesVideoThumbnailer;
}

void PQCSettings::setFiletypesVideoThumbnailer(const QString val) {
    if(val != m_filetypesVideoThumbnailer) {
        m_filetypesVideoThumbnailer = val;
        Q_EMIT filetypesVideoThumbnailerChanged();
    }
}

const QString PQCSettings::getDefaultForFiletypesVideoThumbnailer() const {
        return "ffmpegthumbnailer";
}

void PQCSettings::setDefaultForFiletypesVideoThumbnailer() {
    if("ffmpegthumbnailer" != m_filetypesVideoThumbnailer) {
        m_filetypesVideoThumbnailer = "ffmpegthumbnailer";
        Q_EMIT filetypesVideoThumbnailerChanged();
    }
}

int PQCSettings::getFiletypesVideoVolume() const {
    return m_filetypesVideoVolume;
}

void PQCSettings::setFiletypesVideoVolume(const int val) {
    if(val != m_filetypesVideoVolume) {
        m_filetypesVideoVolume = val;
        Q_EMIT filetypesVideoVolumeChanged();
    }
}

const int PQCSettings::getDefaultForFiletypesVideoVolume() const {
        return 100;
}

void PQCSettings::setDefaultForFiletypesVideoVolume() {
    if(100 != m_filetypesVideoVolume) {
        m_filetypesVideoVolume = 100;
    }
}

bool PQCSettings::getGeneralAutoSaveSettings() const {
    return m_generalAutoSaveSettings;
}

void PQCSettings::setGeneralAutoSaveSettings(const bool val) {
    if(val != m_generalAutoSaveSettings) {
        m_generalAutoSaveSettings = val;
        Q_EMIT generalAutoSaveSettingsChanged();
    }
}

const bool PQCSettings::getDefaultForGeneralAutoSaveSettings() const {
        return false;
}

void PQCSettings::setDefaultForGeneralAutoSaveSettings() {
    if(false != m_generalAutoSaveSettings) {
        m_generalAutoSaveSettings = false;
        Q_EMIT generalAutoSaveSettingsChanged();
    }
}

bool PQCSettings::getGeneralCompactSettings() const {
    return m_generalCompactSettings;
}

void PQCSettings::setGeneralCompactSettings(const bool val) {
    if(val != m_generalCompactSettings) {
        m_generalCompactSettings = val;
        Q_EMIT generalCompactSettingsChanged();
    }
}

const bool PQCSettings::getDefaultForGeneralCompactSettings() const {
        return false;
}

void PQCSettings::setDefaultForGeneralCompactSettings() {
    if(false != m_generalCompactSettings) {
        m_generalCompactSettings = false;
        Q_EMIT generalCompactSettingsChanged();
    }
}

bool PQCSettings::getGeneralDisableAllAnimations() const {
    return m_generalDisableAllAnimations;
}

void PQCSettings::setGeneralDisableAllAnimations(const bool val) {
    if(val != m_generalDisableAllAnimations) {
        m_generalDisableAllAnimations = val;
        Q_EMIT generalDisableAllAnimationsChanged();
    }
}

const bool PQCSettings::getDefaultForGeneralDisableAllAnimations() const {
        return false;
}

void PQCSettings::setDefaultForGeneralDisableAllAnimations() {
    if(false != m_generalDisableAllAnimations) {
        m_generalDisableAllAnimations = false;
        Q_EMIT generalDisableAllAnimationsChanged();
    }
}

QStringList PQCSettings::getGeneralExtensionsAllowUntrusted() const {
    return m_generalExtensionsAllowUntrusted;
}

void PQCSettings::setGeneralExtensionsAllowUntrusted(const QStringList val) {
    if(val != m_generalExtensionsAllowUntrusted) {
        m_generalExtensionsAllowUntrusted = val;
        Q_EMIT generalExtensionsAllowUntrustedChanged();
    }
}

const QStringList PQCSettings::getDefaultForGeneralExtensionsAllowUntrusted() const {
        return QStringList() << "";
}

void PQCSettings::setDefaultForGeneralExtensionsAllowUntrusted() {
    QStringList tmp = QStringList() << "";
    if(tmp != m_generalExtensionsAllowUntrusted) {
        m_generalExtensionsAllowUntrusted = tmp;
        Q_EMIT generalExtensionsAllowUntrustedChanged();
    }
}

QStringList PQCSettings::getGeneralExtensionsEnabled() const {
    return m_generalExtensionsEnabled;
}

void PQCSettings::setGeneralExtensionsEnabled(const QStringList val) {
    if(val != m_generalExtensionsEnabled) {
        m_generalExtensionsEnabled = val;
        Q_EMIT generalExtensionsEnabledChanged();
    }
}

const QStringList PQCSettings::getDefaultForGeneralExtensionsEnabled() const {
        return QStringList() << "CropImage" << "ExportImage" << "FloatingNavigation" << "Histogram" << "ImgurCom" << "MapCurrent" << "QuickActions" << "ScaleImage" << "Wallpaper" << "ThumbnailGenerator";
}

void PQCSettings::setDefaultForGeneralExtensionsEnabled() {
    QStringList tmp = QStringList() << "CropImage" << "ExportImage" << "FloatingNavigation" << "Histogram" << "ImgurCom" << "MapCurrent" << "QuickActions" << "ScaleImage" << "Wallpaper" << "ThumbnailGenerator";
    if(tmp != m_generalExtensionsEnabled) {
        m_generalExtensionsEnabled = tmp;
        Q_EMIT generalExtensionsEnabledChanged();
    }
}

QStringList PQCSettings::getGeneralExtensionsFloatingSetup() const {
    return m_generalExtensionsFloatingSetup;
}

void PQCSettings::setGeneralExtensionsFloatingSetup(const QStringList val) {
    if(val != m_generalExtensionsFloatingSetup) {
        m_generalExtensionsFloatingSetup = val;
        Q_EMIT generalExtensionsFloatingSetupChanged();
    }
}

const QStringList PQCSettings::getDefaultForGeneralExtensionsFloatingSetup() const {
        return QStringList() << "";
}

void PQCSettings::setDefaultForGeneralExtensionsFloatingSetup() {
    QStringList tmp = QStringList() << "";
    if(tmp != m_generalExtensionsFloatingSetup) {
        m_generalExtensionsFloatingSetup = tmp;
        Q_EMIT generalExtensionsFloatingSetupChanged();
    }
}

QString PQCSettings::getGeneralInterfaceVariant() const {
    return m_generalInterfaceVariant;
}

void PQCSettings::setGeneralInterfaceVariant(const QString val) {
    if(val != m_generalInterfaceVariant) {
        m_generalInterfaceVariant = val;
        Q_EMIT generalInterfaceVariantChanged();
    }
}

const QString PQCSettings::getDefaultForGeneralInterfaceVariant() const {
        return "modern";
}

void PQCSettings::setDefaultForGeneralInterfaceVariant() {
    if("modern" != m_generalInterfaceVariant) {
        m_generalInterfaceVariant = "modern";
        Q_EMIT generalInterfaceVariantChanged();
    }
}

QString PQCSettings::getGeneralVersion() const {
    return m_generalVersion;
}

void PQCSettings::setGeneralVersion(const QString val) {
    if(val != m_generalVersion) {
        m_generalVersion = val;
        Q_EMIT generalVersionChanged();
    }
}

const QString PQCSettings::getDefaultForGeneralVersion() const {
        return "";
}

void PQCSettings::setDefaultForGeneralVersion() {
    if("" != m_generalVersion) {
        m_generalVersion = "";
        Q_EMIT generalVersionChanged();
    }
}

bool PQCSettings::getImageviewAdvancedSortAscending() const {
    return m_imageviewAdvancedSortAscending;
}

void PQCSettings::setImageviewAdvancedSortAscending(const bool val) {
    if(val != m_imageviewAdvancedSortAscending) {
        m_imageviewAdvancedSortAscending = val;
        Q_EMIT imageviewAdvancedSortAscendingChanged();
    }
}

const bool PQCSettings::getDefaultForImageviewAdvancedSortAscending() const {
        return true;
}

void PQCSettings::setDefaultForImageviewAdvancedSortAscending() {
    if(true != m_imageviewAdvancedSortAscending) {
        m_imageviewAdvancedSortAscending = true;
        Q_EMIT imageviewAdvancedSortAscendingChanged();
    }
}

QString PQCSettings::getImageviewAdvancedSortCriteria() const {
    return m_imageviewAdvancedSortCriteria;
}

void PQCSettings::setImageviewAdvancedSortCriteria(const QString val) {
    if(val != m_imageviewAdvancedSortCriteria) {
        m_imageviewAdvancedSortCriteria = val;
        Q_EMIT imageviewAdvancedSortCriteriaChanged();
    }
}

const QString PQCSettings::getDefaultForImageviewAdvancedSortCriteria() const {
        return "resolution";
}

void PQCSettings::setDefaultForImageviewAdvancedSortCriteria() {
    if("resolution" != m_imageviewAdvancedSortCriteria) {
        m_imageviewAdvancedSortCriteria = "resolution";
        Q_EMIT imageviewAdvancedSortCriteriaChanged();
    }
}

QStringList PQCSettings::getImageviewAdvancedSortDateCriteria() const {
    return m_imageviewAdvancedSortDateCriteria;
}

void PQCSettings::setImageviewAdvancedSortDateCriteria(const QStringList val) {
    if(val != m_imageviewAdvancedSortDateCriteria) {
        m_imageviewAdvancedSortDateCriteria = val;
        Q_EMIT imageviewAdvancedSortDateCriteriaChanged();
    }
}

const QStringList PQCSettings::getDefaultForImageviewAdvancedSortDateCriteria() const {
        return QStringList() << "exiforiginal" << "exifdigital" << "filecreation" << "filemodification";
}

void PQCSettings::setDefaultForImageviewAdvancedSortDateCriteria() {
    QStringList tmp = QStringList() << "exiforiginal" << "exifdigital" << "filecreation" << "filemodification";
    if(tmp != m_imageviewAdvancedSortDateCriteria) {
        m_imageviewAdvancedSortDateCriteria = tmp;
        Q_EMIT imageviewAdvancedSortDateCriteriaChanged();
    }
}

QString PQCSettings::getImageviewAdvancedSortQuality() const {
    return m_imageviewAdvancedSortQuality;
}

void PQCSettings::setImageviewAdvancedSortQuality(const QString val) {
    if(val != m_imageviewAdvancedSortQuality) {
        m_imageviewAdvancedSortQuality = val;
        Q_EMIT imageviewAdvancedSortQualityChanged();
    }
}

const QString PQCSettings::getDefaultForImageviewAdvancedSortQuality() const {
        return "medium";
}

void PQCSettings::setDefaultForImageviewAdvancedSortQuality() {
    if("medium" != m_imageviewAdvancedSortQuality) {
        m_imageviewAdvancedSortQuality = "medium";
        Q_EMIT imageviewAdvancedSortQualityChanged();
    }
}

bool PQCSettings::getImageviewAlwaysActualSize() const {
    return m_imageviewAlwaysActualSize;
}

void PQCSettings::setImageviewAlwaysActualSize(const bool val) {
    if(val != m_imageviewAlwaysActualSize) {
        m_imageviewAlwaysActualSize = val;
        Q_EMIT imageviewAlwaysActualSizeChanged();
    }
}

const bool PQCSettings::getDefaultForImageviewAlwaysActualSize() const {
        return false;
}

void PQCSettings::setDefaultForImageviewAlwaysActualSize() {
    if(false != m_imageviewAlwaysActualSize) {
        m_imageviewAlwaysActualSize = false;
        Q_EMIT imageviewAlwaysActualSizeChanged();
    }
}

int PQCSettings::getImageviewAnimationDuration() const {
    return m_imageviewAnimationDuration;
}

void PQCSettings::setImageviewAnimationDuration(const int val) {
    if(val != m_imageviewAnimationDuration) {
        m_imageviewAnimationDuration = val;
        Q_EMIT imageviewAnimationDurationChanged();
    }
}

const int PQCSettings::getDefaultForImageviewAnimationDuration() const {
        return 3;
}

void PQCSettings::setDefaultForImageviewAnimationDuration() {
    if(3 != m_imageviewAnimationDuration) {
        m_imageviewAnimationDuration = 3;
    }
}

QString PQCSettings::getImageviewAnimationType() const {
    return m_imageviewAnimationType;
}

void PQCSettings::setImageviewAnimationType(const QString val) {
    if(val != m_imageviewAnimationType) {
        m_imageviewAnimationType = val;
        Q_EMIT imageviewAnimationTypeChanged();
    }
}

const QString PQCSettings::getDefaultForImageviewAnimationType() const {
        return "opacity";
}

void PQCSettings::setDefaultForImageviewAnimationType() {
    if("opacity" != m_imageviewAnimationType) {
        m_imageviewAnimationType = "opacity";
        Q_EMIT imageviewAnimationTypeChanged();
    }
}

int PQCSettings::getImageviewCache() const {
    return m_imageviewCache;
}

void PQCSettings::setImageviewCache(const int val) {
    if(val != m_imageviewCache) {
        m_imageviewCache = val;
        Q_EMIT imageviewCacheChanged();
    }
}

const int PQCSettings::getDefaultForImageviewCache() const {
        return 512;
}

void PQCSettings::setDefaultForImageviewCache() {
    if(512 != m_imageviewCache) {
        m_imageviewCache = 512;
    }
}

QStringList PQCSettings::getImageviewColorSpaceContextMenu() const {
    return m_imageviewColorSpaceContextMenu;
}

void PQCSettings::setImageviewColorSpaceContextMenu(const QStringList val) {
    if(val != m_imageviewColorSpaceContextMenu) {
        m_imageviewColorSpaceContextMenu = val;
        Q_EMIT imageviewColorSpaceContextMenuChanged();
    }
}

const QStringList PQCSettings::getDefaultForImageviewColorSpaceContextMenu() const {
        return QStringList() << "::0" << "::1" << "::2" << "::3" << "::4";
}

void PQCSettings::setDefaultForImageviewColorSpaceContextMenu() {
    QStringList tmp = QStringList() << "::0" << "::1" << "::2" << "::3" << "::4";
    if(tmp != m_imageviewColorSpaceContextMenu) {
        m_imageviewColorSpaceContextMenu = tmp;
        Q_EMIT imageviewColorSpaceContextMenuChanged();
    }
}

QString PQCSettings::getImageviewColorSpaceDefault() const {
    return m_imageviewColorSpaceDefault;
}

void PQCSettings::setImageviewColorSpaceDefault(const QString val) {
    if(val != m_imageviewColorSpaceDefault) {
        m_imageviewColorSpaceDefault = val;
        Q_EMIT imageviewColorSpaceDefaultChanged();
    }
}

const QString PQCSettings::getDefaultForImageviewColorSpaceDefault() const {
        return "";
}

void PQCSettings::setDefaultForImageviewColorSpaceDefault() {
    if("" != m_imageviewColorSpaceDefault) {
        m_imageviewColorSpaceDefault = "";
        Q_EMIT imageviewColorSpaceDefaultChanged();
    }
}

bool PQCSettings::getImageviewColorSpaceEnable() const {
    return m_imageviewColorSpaceEnable;
}

void PQCSettings::setImageviewColorSpaceEnable(const bool val) {
    if(val != m_imageviewColorSpaceEnable) {
        m_imageviewColorSpaceEnable = val;
        Q_EMIT imageviewColorSpaceEnableChanged();
    }
}

const bool PQCSettings::getDefaultForImageviewColorSpaceEnable() const {
        return true;
}

void PQCSettings::setDefaultForImageviewColorSpaceEnable() {
    if(true != m_imageviewColorSpaceEnable) {
        m_imageviewColorSpaceEnable = true;
        Q_EMIT imageviewColorSpaceEnableChanged();
    }
}

bool PQCSettings::getImageviewColorSpaceLoadEmbedded() const {
    return m_imageviewColorSpaceLoadEmbedded;
}

void PQCSettings::setImageviewColorSpaceLoadEmbedded(const bool val) {
    if(val != m_imageviewColorSpaceLoadEmbedded) {
        m_imageviewColorSpaceLoadEmbedded = val;
        Q_EMIT imageviewColorSpaceLoadEmbeddedChanged();
    }
}

const bool PQCSettings::getDefaultForImageviewColorSpaceLoadEmbedded() const {
        return true;
}

void PQCSettings::setDefaultForImageviewColorSpaceLoadEmbedded() {
    if(true != m_imageviewColorSpaceLoadEmbedded) {
        m_imageviewColorSpaceLoadEmbedded = true;
        Q_EMIT imageviewColorSpaceLoadEmbeddedChanged();
    }
}

bool PQCSettings::getImageviewEscapeExitArchive() const {
    return m_imageviewEscapeExitArchive;
}

void PQCSettings::setImageviewEscapeExitArchive(const bool val) {
    if(val != m_imageviewEscapeExitArchive) {
        m_imageviewEscapeExitArchive = val;
        Q_EMIT imageviewEscapeExitArchiveChanged();
    }
}

const bool PQCSettings::getDefaultForImageviewEscapeExitArchive() const {
        return true;
}

void PQCSettings::setDefaultForImageviewEscapeExitArchive() {
    if(true != m_imageviewEscapeExitArchive) {
        m_imageviewEscapeExitArchive = true;
        Q_EMIT imageviewEscapeExitArchiveChanged();
    }
}

bool PQCSettings::getImageviewEscapeExitBarcodes() const {
    return m_imageviewEscapeExitBarcodes;
}

void PQCSettings::setImageviewEscapeExitBarcodes(const bool val) {
    if(val != m_imageviewEscapeExitBarcodes) {
        m_imageviewEscapeExitBarcodes = val;
        Q_EMIT imageviewEscapeExitBarcodesChanged();
    }
}

const bool PQCSettings::getDefaultForImageviewEscapeExitBarcodes() const {
        return true;
}

void PQCSettings::setDefaultForImageviewEscapeExitBarcodes() {
    if(true != m_imageviewEscapeExitBarcodes) {
        m_imageviewEscapeExitBarcodes = true;
        Q_EMIT imageviewEscapeExitBarcodesChanged();
    }
}

bool PQCSettings::getImageviewEscapeExitDocument() const {
    return m_imageviewEscapeExitDocument;
}

void PQCSettings::setImageviewEscapeExitDocument(const bool val) {
    if(val != m_imageviewEscapeExitDocument) {
        m_imageviewEscapeExitDocument = val;
        Q_EMIT imageviewEscapeExitDocumentChanged();
    }
}

const bool PQCSettings::getDefaultForImageviewEscapeExitDocument() const {
        return true;
}

void PQCSettings::setDefaultForImageviewEscapeExitDocument() {
    if(true != m_imageviewEscapeExitDocument) {
        m_imageviewEscapeExitDocument = true;
        Q_EMIT imageviewEscapeExitDocumentChanged();
    }
}

bool PQCSettings::getImageviewEscapeExitFilter() const {
    return m_imageviewEscapeExitFilter;
}

void PQCSettings::setImageviewEscapeExitFilter(const bool val) {
    if(val != m_imageviewEscapeExitFilter) {
        m_imageviewEscapeExitFilter = val;
        Q_EMIT imageviewEscapeExitFilterChanged();
    }
}

const bool PQCSettings::getDefaultForImageviewEscapeExitFilter() const {
        return true;
}

void PQCSettings::setDefaultForImageviewEscapeExitFilter() {
    if(true != m_imageviewEscapeExitFilter) {
        m_imageviewEscapeExitFilter = true;
        Q_EMIT imageviewEscapeExitFilterChanged();
    }
}

bool PQCSettings::getImageviewEscapeExitSphere() const {
    return m_imageviewEscapeExitSphere;
}

void PQCSettings::setImageviewEscapeExitSphere(const bool val) {
    if(val != m_imageviewEscapeExitSphere) {
        m_imageviewEscapeExitSphere = val;
        Q_EMIT imageviewEscapeExitSphereChanged();
    }
}

const bool PQCSettings::getDefaultForImageviewEscapeExitSphere() const {
        return true;
}

void PQCSettings::setDefaultForImageviewEscapeExitSphere() {
    if(true != m_imageviewEscapeExitSphere) {
        m_imageviewEscapeExitSphere = true;
        Q_EMIT imageviewEscapeExitSphereChanged();
    }
}

bool PQCSettings::getImageviewFitInWindow() const {
    return m_imageviewFitInWindow;
}

void PQCSettings::setImageviewFitInWindow(const bool val) {
    if(val != m_imageviewFitInWindow) {
        m_imageviewFitInWindow = val;
        Q_EMIT imageviewFitInWindowChanged();
    }
}

const bool PQCSettings::getDefaultForImageviewFitInWindow() const {
        return false;
}

void PQCSettings::setDefaultForImageviewFitInWindow() {
    if(false != m_imageviewFitInWindow) {
        m_imageviewFitInWindow = false;
        Q_EMIT imageviewFitInWindowChanged();
    }
}

int PQCSettings::getImageviewHideCursorTimeout() const {
    return m_imageviewHideCursorTimeout;
}

void PQCSettings::setImageviewHideCursorTimeout(const int val) {
    if(val != m_imageviewHideCursorTimeout) {
        m_imageviewHideCursorTimeout = val;
        Q_EMIT imageviewHideCursorTimeoutChanged();
    }
}

const int PQCSettings::getDefaultForImageviewHideCursorTimeout() const {
        return 1;
}

void PQCSettings::setDefaultForImageviewHideCursorTimeout() {
    if(1 != m_imageviewHideCursorTimeout) {
        m_imageviewHideCursorTimeout = 1;
    }
}

int PQCSettings::getImageviewInterpolationFullImage() const {
    return m_imageviewInterpolationFullImage;
}

void PQCSettings::setImageviewInterpolationFullImage(const int val) {
    if(val != m_imageviewInterpolationFullImage) {
        m_imageviewInterpolationFullImage = val;
        Q_EMIT imageviewInterpolationFullImageChanged();
    }
}

const int PQCSettings::getDefaultForImageviewInterpolationFullImage() const {
        return 1;
}

void PQCSettings::setDefaultForImageviewInterpolationFullImage() {
    if(1 != m_imageviewInterpolationFullImage) {
        m_imageviewInterpolationFullImage = 1;
    }
}

bool PQCSettings::getImageviewLoopThroughFolder() const {
    return m_imageviewLoopThroughFolder;
}

void PQCSettings::setImageviewLoopThroughFolder(const bool val) {
    if(val != m_imageviewLoopThroughFolder) {
        m_imageviewLoopThroughFolder = val;
        Q_EMIT imageviewLoopThroughFolderChanged();
    }
}

const bool PQCSettings::getDefaultForImageviewLoopThroughFolder() const {
        return true;
}

void PQCSettings::setDefaultForImageviewLoopThroughFolder() {
    if(true != m_imageviewLoopThroughFolder) {
        m_imageviewLoopThroughFolder = true;
        Q_EMIT imageviewLoopThroughFolderChanged();
    }
}

int PQCSettings::getImageviewMargin() const {
    return m_imageviewMargin;
}

void PQCSettings::setImageviewMargin(const int val) {
    if(val != m_imageviewMargin) {
        m_imageviewMargin = val;
        Q_EMIT imageviewMarginChanged();
    }
}

const int PQCSettings::getDefaultForImageviewMargin() const {
        return 5;
}

void PQCSettings::setDefaultForImageviewMargin() {
    if(5 != m_imageviewMargin) {
        m_imageviewMargin = 5;
    }
}

int PQCSettings::getImageviewMinimapSizeLevel() const {
    return m_imageviewMinimapSizeLevel;
}

void PQCSettings::setImageviewMinimapSizeLevel(const int val) {
    if(val != m_imageviewMinimapSizeLevel) {
        m_imageviewMinimapSizeLevel = val;
        Q_EMIT imageviewMinimapSizeLevelChanged();
    }
}

const int PQCSettings::getDefaultForImageviewMinimapSizeLevel() const {
        return 0;
}

void PQCSettings::setDefaultForImageviewMinimapSizeLevel() {
    if(0 != m_imageviewMinimapSizeLevel) {
        m_imageviewMinimapSizeLevel = 0;
    }
}

bool PQCSettings::getImageviewMirrorAnimate() const {
    return m_imageviewMirrorAnimate;
}

void PQCSettings::setImageviewMirrorAnimate(const bool val) {
    if(val != m_imageviewMirrorAnimate) {
        m_imageviewMirrorAnimate = val;
        Q_EMIT imageviewMirrorAnimateChanged();
    }
}

const bool PQCSettings::getDefaultForImageviewMirrorAnimate() const {
        return true;
}

void PQCSettings::setDefaultForImageviewMirrorAnimate() {
    if(true != m_imageviewMirrorAnimate) {
        m_imageviewMirrorAnimate = true;
        Q_EMIT imageviewMirrorAnimateChanged();
    }
}

int PQCSettings::getImageviewMouseWheelRepeatDelay() const {
    return m_imageviewMouseWheelRepeatDelay;
}

void PQCSettings::setImageviewMouseWheelRepeatDelay(const int val) {
    if(val != m_imageviewMouseWheelRepeatDelay) {
        m_imageviewMouseWheelRepeatDelay = val;
        Q_EMIT imageviewMouseWheelRepeatDelayChanged();
    }
}

const int PQCSettings::getDefaultForImageviewMouseWheelRepeatDelay() const {
        return 0;
}

void PQCSettings::setDefaultForImageviewMouseWheelRepeatDelay() {
    if(0 != m_imageviewMouseWheelRepeatDelay) {
        m_imageviewMouseWheelRepeatDelay = 0;
    }
}

int PQCSettings::getImageviewPreloadInBackground() const {
    return m_imageviewPreloadInBackground;
}

void PQCSettings::setImageviewPreloadInBackground(const int val) {
    if(val != m_imageviewPreloadInBackground) {
        m_imageviewPreloadInBackground = val;
        Q_EMIT imageviewPreloadInBackgroundChanged();
    }
}

const int PQCSettings::getDefaultForImageviewPreloadInBackground() const {
        return 1;
}

void PQCSettings::setDefaultForImageviewPreloadInBackground() {
    if(1 != m_imageviewPreloadInBackground) {
        m_imageviewPreloadInBackground = 1;
    }
}

bool PQCSettings::getImageviewPreserveMirror() const {
    return m_imageviewPreserveMirror;
}

void PQCSettings::setImageviewPreserveMirror(const bool val) {
    if(val != m_imageviewPreserveMirror) {
        m_imageviewPreserveMirror = val;
        Q_EMIT imageviewPreserveMirrorChanged();
    }
}

const bool PQCSettings::getDefaultForImageviewPreserveMirror() const {
        return false;
}

void PQCSettings::setDefaultForImageviewPreserveMirror() {
    if(false != m_imageviewPreserveMirror) {
        m_imageviewPreserveMirror = false;
        Q_EMIT imageviewPreserveMirrorChanged();
    }
}

bool PQCSettings::getImageviewPreserveRotation() const {
    return m_imageviewPreserveRotation;
}

void PQCSettings::setImageviewPreserveRotation(const bool val) {
    if(val != m_imageviewPreserveRotation) {
        m_imageviewPreserveRotation = val;
        Q_EMIT imageviewPreserveRotationChanged();
    }
}

const bool PQCSettings::getDefaultForImageviewPreserveRotation() const {
        return false;
}

void PQCSettings::setDefaultForImageviewPreserveRotation() {
    if(false != m_imageviewPreserveRotation) {
        m_imageviewPreserveRotation = false;
        Q_EMIT imageviewPreserveRotationChanged();
    }
}

bool PQCSettings::getImageviewPreserveZoom() const {
    return m_imageviewPreserveZoom;
}

void PQCSettings::setImageviewPreserveZoom(const bool val) {
    if(val != m_imageviewPreserveZoom) {
        m_imageviewPreserveZoom = val;
        Q_EMIT imageviewPreserveZoomChanged();
    }
}

const bool PQCSettings::getDefaultForImageviewPreserveZoom() const {
        return false;
}

void PQCSettings::setDefaultForImageviewPreserveZoom() {
    if(false != m_imageviewPreserveZoom) {
        m_imageviewPreserveZoom = false;
        Q_EMIT imageviewPreserveZoomChanged();
    }
}

bool PQCSettings::getImageviewRememberZoomRotationMirror() const {
    return m_imageviewRememberZoomRotationMirror;
}

void PQCSettings::setImageviewRememberZoomRotationMirror(const bool val) {
    if(val != m_imageviewRememberZoomRotationMirror) {
        m_imageviewRememberZoomRotationMirror = val;
        Q_EMIT imageviewRememberZoomRotationMirrorChanged();
    }
}

const bool PQCSettings::getDefaultForImageviewRememberZoomRotationMirror() const {
        return false;
}

void PQCSettings::setDefaultForImageviewRememberZoomRotationMirror() {
    if(false != m_imageviewRememberZoomRotationMirror) {
        m_imageviewRememberZoomRotationMirror = false;
        Q_EMIT imageviewRememberZoomRotationMirrorChanged();
    }
}

bool PQCSettings::getImageviewRescalingSmooth() const {
    return m_imageviewRescalingSmooth;
}

void PQCSettings::setImageviewRescalingSmooth(const bool val) {
    if(val != m_imageviewRescalingSmooth) {
        m_imageviewRescalingSmooth = val;
        Q_EMIT imageviewRescalingSmoothChanged();
    }
}

const bool PQCSettings::getDefaultForImageviewRescalingSmooth() const {
        return true;
}

void PQCSettings::setDefaultForImageviewRescalingSmooth() {
    if(true != m_imageviewRescalingSmooth) {
        m_imageviewRescalingSmooth = true;
        Q_EMIT imageviewRescalingSmoothChanged();
    }
}

int PQCSettings::getImageviewRescalingWhichImages() const {
    return m_imageviewRescalingWhichImages;
}

void PQCSettings::setImageviewRescalingWhichImages(const int val) {
    if(val != m_imageviewRescalingWhichImages) {
        m_imageviewRescalingWhichImages = val;
        Q_EMIT imageviewRescalingWhichImagesChanged();
    }
}

const int PQCSettings::getDefaultForImageviewRescalingWhichImages() const {
        return 2;
}

void PQCSettings::setDefaultForImageviewRescalingWhichImages() {
    if(2 != m_imageviewRescalingWhichImages) {
        m_imageviewRescalingWhichImages = 2;
    }
}

int PQCSettings::getImageviewResetViewAutoHideTimeout() const {
    return m_imageviewResetViewAutoHideTimeout;
}

void PQCSettings::setImageviewResetViewAutoHideTimeout(const int val) {
    if(val != m_imageviewResetViewAutoHideTimeout) {
        m_imageviewResetViewAutoHideTimeout = val;
        Q_EMIT imageviewResetViewAutoHideTimeoutChanged();
    }
}

const int PQCSettings::getDefaultForImageviewResetViewAutoHideTimeout() const {
        return 1000;
}

void PQCSettings::setDefaultForImageviewResetViewAutoHideTimeout() {
    if(1000 != m_imageviewResetViewAutoHideTimeout) {
        m_imageviewResetViewAutoHideTimeout = 1000;
    }
}

bool PQCSettings::getImageviewResetViewShow() const {
    return m_imageviewResetViewShow;
}

void PQCSettings::setImageviewResetViewShow(const bool val) {
    if(val != m_imageviewResetViewShow) {
        m_imageviewResetViewShow = val;
        Q_EMIT imageviewResetViewShowChanged();
    }
}

const bool PQCSettings::getDefaultForImageviewResetViewShow() const {
        return false;
}

void PQCSettings::setDefaultForImageviewResetViewShow() {
    if(false != m_imageviewResetViewShow) {
        m_imageviewResetViewShow = false;
        Q_EMIT imageviewResetViewShowChanged();
    }
}

bool PQCSettings::getImageviewRespectDevicePixelRatio() const {
    return m_imageviewRespectDevicePixelRatio;
}

void PQCSettings::setImageviewRespectDevicePixelRatio(const bool val) {
    if(val != m_imageviewRespectDevicePixelRatio) {
        m_imageviewRespectDevicePixelRatio = val;
        Q_EMIT imageviewRespectDevicePixelRatioChanged();
    }
}

const bool PQCSettings::getDefaultForImageviewRespectDevicePixelRatio() const {
        return true;
}

void PQCSettings::setDefaultForImageviewRespectDevicePixelRatio() {
    if(true != m_imageviewRespectDevicePixelRatio) {
        m_imageviewRespectDevicePixelRatio = true;
        Q_EMIT imageviewRespectDevicePixelRatioChanged();
    }
}

bool PQCSettings::getImageviewShowMinimap() const {
    return m_imageviewShowMinimap;
}

void PQCSettings::setImageviewShowMinimap(const bool val) {
    if(val != m_imageviewShowMinimap) {
        m_imageviewShowMinimap = val;
        Q_EMIT imageviewShowMinimapChanged();
    }
}

const bool PQCSettings::getDefaultForImageviewShowMinimap() const {
        return true;
}

void PQCSettings::setDefaultForImageviewShowMinimap() {
    if(true != m_imageviewShowMinimap) {
        m_imageviewShowMinimap = true;
        Q_EMIT imageviewShowMinimapChanged();
    }
}

int PQCSettings::getImageviewSiblingFileMaxIterations() const {
    return m_imageviewSiblingFileMaxIterations;
}

void PQCSettings::setImageviewSiblingFileMaxIterations(const int val) {
    if(val != m_imageviewSiblingFileMaxIterations) {
        m_imageviewSiblingFileMaxIterations = val;
        Q_EMIT imageviewSiblingFileMaxIterationsChanged();
    }
}

const int PQCSettings::getDefaultForImageviewSiblingFileMaxIterations() const {
        return 100;
}

void PQCSettings::setDefaultForImageviewSiblingFileMaxIterations() {
    if(100 != m_imageviewSiblingFileMaxIterations) {
        m_imageviewSiblingFileMaxIterations = 100;
    }
}

int PQCSettings::getImageviewSiblingFileMaxLevelUp() const {
    return m_imageviewSiblingFileMaxLevelUp;
}

void PQCSettings::setImageviewSiblingFileMaxLevelUp(const int val) {
    if(val != m_imageviewSiblingFileMaxLevelUp) {
        m_imageviewSiblingFileMaxLevelUp = val;
        Q_EMIT imageviewSiblingFileMaxLevelUpChanged();
    }
}

const int PQCSettings::getDefaultForImageviewSiblingFileMaxLevelUp() const {
        return 8;
}

void PQCSettings::setDefaultForImageviewSiblingFileMaxLevelUp() {
    if(8 != m_imageviewSiblingFileMaxLevelUp) {
        m_imageviewSiblingFileMaxLevelUp = 8;
    }
}

int PQCSettings::getImageviewSiblingFilemaxLevelDown() const {
    return m_imageviewSiblingFilemaxLevelDown;
}

void PQCSettings::setImageviewSiblingFilemaxLevelDown(const int val) {
    if(val != m_imageviewSiblingFilemaxLevelDown) {
        m_imageviewSiblingFilemaxLevelDown = val;
        Q_EMIT imageviewSiblingFilemaxLevelDownChanged();
    }
}

const int PQCSettings::getDefaultForImageviewSiblingFilemaxLevelDown() const {
        return 2;
}

void PQCSettings::setDefaultForImageviewSiblingFilemaxLevelDown() {
    if(2 != m_imageviewSiblingFilemaxLevelDown) {
        m_imageviewSiblingFilemaxLevelDown = 2;
    }
}

bool PQCSettings::getImageviewSortImagesAscending() const {
    return m_imageviewSortImagesAscending;
}

void PQCSettings::setImageviewSortImagesAscending(const bool val) {
    if(val != m_imageviewSortImagesAscending) {
        m_imageviewSortImagesAscending = val;
        Q_EMIT imageviewSortImagesAscendingChanged();
    }
}

const bool PQCSettings::getDefaultForImageviewSortImagesAscending() const {
        return true;
}

void PQCSettings::setDefaultForImageviewSortImagesAscending() {
    if(true != m_imageviewSortImagesAscending) {
        m_imageviewSortImagesAscending = true;
        Q_EMIT imageviewSortImagesAscendingChanged();
    }
}

QString PQCSettings::getImageviewSortImagesBy() const {
    return m_imageviewSortImagesBy;
}

void PQCSettings::setImageviewSortImagesBy(const QString val) {
    if(val != m_imageviewSortImagesBy) {
        m_imageviewSortImagesBy = val;
        Q_EMIT imageviewSortImagesByChanged();
    }
}

const QString PQCSettings::getDefaultForImageviewSortImagesBy() const {
        return "naturalname";
}

void PQCSettings::setDefaultForImageviewSortImagesBy() {
    if("naturalname" != m_imageviewSortImagesBy) {
        m_imageviewSortImagesBy = "naturalname";
        Q_EMIT imageviewSortImagesByChanged();
    }
}

bool PQCSettings::getImageviewTransparencyMarker() const {
    return m_imageviewTransparencyMarker;
}

void PQCSettings::setImageviewTransparencyMarker(const bool val) {
    if(val != m_imageviewTransparencyMarker) {
        m_imageviewTransparencyMarker = val;
        Q_EMIT imageviewTransparencyMarkerChanged();
    }
}

const bool PQCSettings::getDefaultForImageviewTransparencyMarker() const {
        return false;
}

void PQCSettings::setDefaultForImageviewTransparencyMarker() {
    if(false != m_imageviewTransparencyMarker) {
        m_imageviewTransparencyMarker = false;
        Q_EMIT imageviewTransparencyMarkerChanged();
    }
}

bool PQCSettings::getImageviewUseMouseLeftButtonForImageMove() const {
    return m_imageviewUseMouseLeftButtonForImageMove;
}

void PQCSettings::setImageviewUseMouseLeftButtonForImageMove(const bool val) {
    if(val != m_imageviewUseMouseLeftButtonForImageMove) {
        m_imageviewUseMouseLeftButtonForImageMove = val;
        Q_EMIT imageviewUseMouseLeftButtonForImageMoveChanged();
    }
}

const bool PQCSettings::getDefaultForImageviewUseMouseLeftButtonForImageMove() const {
        return true;
}

void PQCSettings::setDefaultForImageviewUseMouseLeftButtonForImageMove() {
    if(true != m_imageviewUseMouseLeftButtonForImageMove) {
        m_imageviewUseMouseLeftButtonForImageMove = true;
        Q_EMIT imageviewUseMouseLeftButtonForImageMoveChanged();
    }
}

bool PQCSettings::getImageviewUseMouseWheelForImageMove() const {
    return m_imageviewUseMouseWheelForImageMove;
}

void PQCSettings::setImageviewUseMouseWheelForImageMove(const bool val) {
    if(val != m_imageviewUseMouseWheelForImageMove) {
        m_imageviewUseMouseWheelForImageMove = val;
        Q_EMIT imageviewUseMouseWheelForImageMoveChanged();
    }
}

const bool PQCSettings::getDefaultForImageviewUseMouseWheelForImageMove() const {
        return false;
}

void PQCSettings::setDefaultForImageviewUseMouseWheelForImageMove() {
    if(false != m_imageviewUseMouseWheelForImageMove) {
        m_imageviewUseMouseWheelForImageMove = false;
        Q_EMIT imageviewUseMouseWheelForImageMoveChanged();
    }
}

int PQCSettings::getImageviewZoomMax() const {
    return m_imageviewZoomMax;
}

void PQCSettings::setImageviewZoomMax(const int val) {
    if(val != m_imageviewZoomMax) {
        m_imageviewZoomMax = val;
        Q_EMIT imageviewZoomMaxChanged();
    }
}

const int PQCSettings::getDefaultForImageviewZoomMax() const {
        return 500;
}

void PQCSettings::setDefaultForImageviewZoomMax() {
    if(500 != m_imageviewZoomMax) {
        m_imageviewZoomMax = 500;
    }
}

bool PQCSettings::getImageviewZoomMaxEnabled() const {
    return m_imageviewZoomMaxEnabled;
}

void PQCSettings::setImageviewZoomMaxEnabled(const bool val) {
    if(val != m_imageviewZoomMaxEnabled) {
        m_imageviewZoomMaxEnabled = val;
        Q_EMIT imageviewZoomMaxEnabledChanged();
    }
}

const bool PQCSettings::getDefaultForImageviewZoomMaxEnabled() const {
        return true;
}

void PQCSettings::setDefaultForImageviewZoomMaxEnabled() {
    if(true != m_imageviewZoomMaxEnabled) {
        m_imageviewZoomMaxEnabled = true;
        Q_EMIT imageviewZoomMaxEnabledChanged();
    }
}

int PQCSettings::getImageviewZoomMin() const {
    return m_imageviewZoomMin;
}

void PQCSettings::setImageviewZoomMin(const int val) {
    if(val != m_imageviewZoomMin) {
        m_imageviewZoomMin = val;
        Q_EMIT imageviewZoomMinChanged();
    }
}

const int PQCSettings::getDefaultForImageviewZoomMin() const {
        return 20;
}

void PQCSettings::setDefaultForImageviewZoomMin() {
    if(20 != m_imageviewZoomMin) {
        m_imageviewZoomMin = 20;
    }
}

bool PQCSettings::getImageviewZoomMinEnabled() const {
    return m_imageviewZoomMinEnabled;
}

void PQCSettings::setImageviewZoomMinEnabled(const bool val) {
    if(val != m_imageviewZoomMinEnabled) {
        m_imageviewZoomMinEnabled = val;
        Q_EMIT imageviewZoomMinEnabledChanged();
    }
}

const bool PQCSettings::getDefaultForImageviewZoomMinEnabled() const {
        return true;
}

void PQCSettings::setDefaultForImageviewZoomMinEnabled() {
    if(true != m_imageviewZoomMinEnabled) {
        m_imageviewZoomMinEnabled = true;
        Q_EMIT imageviewZoomMinEnabledChanged();
    }
}

int PQCSettings::getImageviewZoomSpeed() const {
    return m_imageviewZoomSpeed;
}

void PQCSettings::setImageviewZoomSpeed(const int val) {
    if(val != m_imageviewZoomSpeed) {
        m_imageviewZoomSpeed = val;
        Q_EMIT imageviewZoomSpeedChanged();
    }
}

const int PQCSettings::getDefaultForImageviewZoomSpeed() const {
        return 20;
}

void PQCSettings::setDefaultForImageviewZoomSpeed() {
    if(20 != m_imageviewZoomSpeed) {
        m_imageviewZoomSpeed = 20;
    }
}

bool PQCSettings::getImageviewZoomSpeedRelative() const {
    return m_imageviewZoomSpeedRelative;
}

void PQCSettings::setImageviewZoomSpeedRelative(const bool val) {
    if(val != m_imageviewZoomSpeedRelative) {
        m_imageviewZoomSpeedRelative = val;
        Q_EMIT imageviewZoomSpeedRelativeChanged();
    }
}

const bool PQCSettings::getDefaultForImageviewZoomSpeedRelative() const {
        return true;
}

void PQCSettings::setDefaultForImageviewZoomSpeedRelative() {
    if(true != m_imageviewZoomSpeedRelative) {
        m_imageviewZoomSpeedRelative = true;
        Q_EMIT imageviewZoomSpeedRelativeChanged();
    }
}

bool PQCSettings::getImageviewZoomToCenter() const {
    return m_imageviewZoomToCenter;
}

void PQCSettings::setImageviewZoomToCenter(const bool val) {
    if(val != m_imageviewZoomToCenter) {
        m_imageviewZoomToCenter = val;
        Q_EMIT imageviewZoomToCenterChanged();
    }
}

const bool PQCSettings::getDefaultForImageviewZoomToCenter() const {
        return false;
}

void PQCSettings::setDefaultForImageviewZoomToCenter() {
    if(false != m_imageviewZoomToCenter) {
        m_imageviewZoomToCenter = false;
        Q_EMIT imageviewZoomToCenterChanged();
    }
}

QString PQCSettings::getInterfaceAccentColor() const {
    return m_interfaceAccentColor;
}

void PQCSettings::setInterfaceAccentColor(const QString val) {
    if(val != m_interfaceAccentColor) {
        m_interfaceAccentColor = val;
        Q_EMIT interfaceAccentColorChanged();
    }
}

const QString PQCSettings::getDefaultForInterfaceAccentColor() const {
        return "#222222";
}

void PQCSettings::setDefaultForInterfaceAccentColor() {
    if("#222222" != m_interfaceAccentColor) {
        m_interfaceAccentColor = "#222222";
        Q_EMIT interfaceAccentColorChanged();
    }
}

bool PQCSettings::getInterfaceAllowMultipleInstances() const {
    return m_interfaceAllowMultipleInstances;
}

void PQCSettings::setInterfaceAllowMultipleInstances(const bool val) {
    if(val != m_interfaceAllowMultipleInstances) {
        m_interfaceAllowMultipleInstances = val;
        Q_EMIT interfaceAllowMultipleInstancesChanged();
    }
}

const bool PQCSettings::getDefaultForInterfaceAllowMultipleInstances() const {
        return false;
}

void PQCSettings::setDefaultForInterfaceAllowMultipleInstances() {
    if(false != m_interfaceAllowMultipleInstances) {
        m_interfaceAllowMultipleInstances = false;
        Q_EMIT interfaceAllowMultipleInstancesChanged();
    }
}

bool PQCSettings::getInterfaceBackgroundCustomOverlay() const {
    return m_interfaceBackgroundCustomOverlay;
}

void PQCSettings::setInterfaceBackgroundCustomOverlay(const bool val) {
    if(val != m_interfaceBackgroundCustomOverlay) {
        m_interfaceBackgroundCustomOverlay = val;
        Q_EMIT interfaceBackgroundCustomOverlayChanged();
    }
}

const bool PQCSettings::getDefaultForInterfaceBackgroundCustomOverlay() const {
        return false;
}

void PQCSettings::setDefaultForInterfaceBackgroundCustomOverlay() {
    if(false != m_interfaceBackgroundCustomOverlay) {
        m_interfaceBackgroundCustomOverlay = false;
        Q_EMIT interfaceBackgroundCustomOverlayChanged();
    }
}

QString PQCSettings::getInterfaceBackgroundCustomOverlayColor() const {
    return m_interfaceBackgroundCustomOverlayColor;
}

void PQCSettings::setInterfaceBackgroundCustomOverlayColor(const QString val) {
    if(val != m_interfaceBackgroundCustomOverlayColor) {
        m_interfaceBackgroundCustomOverlayColor = val;
        Q_EMIT interfaceBackgroundCustomOverlayColorChanged();
    }
}

const QString PQCSettings::getDefaultForInterfaceBackgroundCustomOverlayColor() const {
        return "";
}

void PQCSettings::setDefaultForInterfaceBackgroundCustomOverlayColor() {
    if("" != m_interfaceBackgroundCustomOverlayColor) {
        m_interfaceBackgroundCustomOverlayColor = "";
        Q_EMIT interfaceBackgroundCustomOverlayColorChanged();
    }
}

bool PQCSettings::getInterfaceBackgroundFullyTransparent() const {
    return m_interfaceBackgroundFullyTransparent;
}

void PQCSettings::setInterfaceBackgroundFullyTransparent(const bool val) {
    if(val != m_interfaceBackgroundFullyTransparent) {
        m_interfaceBackgroundFullyTransparent = val;
        Q_EMIT interfaceBackgroundFullyTransparentChanged();
    }
}

const bool PQCSettings::getDefaultForInterfaceBackgroundFullyTransparent() const {
        return false;
}

void PQCSettings::setDefaultForInterfaceBackgroundFullyTransparent() {
    if(false != m_interfaceBackgroundFullyTransparent) {
        m_interfaceBackgroundFullyTransparent = false;
        Q_EMIT interfaceBackgroundFullyTransparentChanged();
    }
}

bool PQCSettings::getInterfaceBackgroundImageCenter() const {
    return m_interfaceBackgroundImageCenter;
}

void PQCSettings::setInterfaceBackgroundImageCenter(const bool val) {
    if(val != m_interfaceBackgroundImageCenter) {
        m_interfaceBackgroundImageCenter = val;
        Q_EMIT interfaceBackgroundImageCenterChanged();
    }
}

const bool PQCSettings::getDefaultForInterfaceBackgroundImageCenter() const {
        return false;
}

void PQCSettings::setDefaultForInterfaceBackgroundImageCenter() {
    if(false != m_interfaceBackgroundImageCenter) {
        m_interfaceBackgroundImageCenter = false;
        Q_EMIT interfaceBackgroundImageCenterChanged();
    }
}

QString PQCSettings::getInterfaceBackgroundImagePath() const {
    return m_interfaceBackgroundImagePath;
}

void PQCSettings::setInterfaceBackgroundImagePath(const QString val) {
    if(val != m_interfaceBackgroundImagePath) {
        m_interfaceBackgroundImagePath = val;
        Q_EMIT interfaceBackgroundImagePathChanged();
    }
}

const QString PQCSettings::getDefaultForInterfaceBackgroundImagePath() const {
        return "";
}

void PQCSettings::setDefaultForInterfaceBackgroundImagePath() {
    if("" != m_interfaceBackgroundImagePath) {
        m_interfaceBackgroundImagePath = "";
        Q_EMIT interfaceBackgroundImagePathChanged();
    }
}

bool PQCSettings::getInterfaceBackgroundImageScale() const {
    return m_interfaceBackgroundImageScale;
}

void PQCSettings::setInterfaceBackgroundImageScale(const bool val) {
    if(val != m_interfaceBackgroundImageScale) {
        m_interfaceBackgroundImageScale = val;
        Q_EMIT interfaceBackgroundImageScaleChanged();
    }
}

const bool PQCSettings::getDefaultForInterfaceBackgroundImageScale() const {
        return true;
}

void PQCSettings::setDefaultForInterfaceBackgroundImageScale() {
    if(true != m_interfaceBackgroundImageScale) {
        m_interfaceBackgroundImageScale = true;
        Q_EMIT interfaceBackgroundImageScaleChanged();
    }
}

bool PQCSettings::getInterfaceBackgroundImageScaleCrop() const {
    return m_interfaceBackgroundImageScaleCrop;
}

void PQCSettings::setInterfaceBackgroundImageScaleCrop(const bool val) {
    if(val != m_interfaceBackgroundImageScaleCrop) {
        m_interfaceBackgroundImageScaleCrop = val;
        Q_EMIT interfaceBackgroundImageScaleCropChanged();
    }
}

const bool PQCSettings::getDefaultForInterfaceBackgroundImageScaleCrop() const {
        return false;
}

void PQCSettings::setDefaultForInterfaceBackgroundImageScaleCrop() {
    if(false != m_interfaceBackgroundImageScaleCrop) {
        m_interfaceBackgroundImageScaleCrop = false;
        Q_EMIT interfaceBackgroundImageScaleCropChanged();
    }
}

bool PQCSettings::getInterfaceBackgroundImageScreenshot() const {
    return m_interfaceBackgroundImageScreenshot;
}

void PQCSettings::setInterfaceBackgroundImageScreenshot(const bool val) {
    if(val != m_interfaceBackgroundImageScreenshot) {
        m_interfaceBackgroundImageScreenshot = val;
        Q_EMIT interfaceBackgroundImageScreenshotChanged();
    }
}

const bool PQCSettings::getDefaultForInterfaceBackgroundImageScreenshot() const {
        return false;
}

void PQCSettings::setDefaultForInterfaceBackgroundImageScreenshot() {
    if(false != m_interfaceBackgroundImageScreenshot) {
        m_interfaceBackgroundImageScreenshot = false;
        Q_EMIT interfaceBackgroundImageScreenshotChanged();
    }
}

bool PQCSettings::getInterfaceBackgroundImageStretch() const {
    return m_interfaceBackgroundImageStretch;
}

void PQCSettings::setInterfaceBackgroundImageStretch(const bool val) {
    if(val != m_interfaceBackgroundImageStretch) {
        m_interfaceBackgroundImageStretch = val;
        Q_EMIT interfaceBackgroundImageStretchChanged();
    }
}

const bool PQCSettings::getDefaultForInterfaceBackgroundImageStretch() const {
        return false;
}

void PQCSettings::setDefaultForInterfaceBackgroundImageStretch() {
    if(false != m_interfaceBackgroundImageStretch) {
        m_interfaceBackgroundImageStretch = false;
        Q_EMIT interfaceBackgroundImageStretchChanged();
    }
}

bool PQCSettings::getInterfaceBackgroundImageTile() const {
    return m_interfaceBackgroundImageTile;
}

void PQCSettings::setInterfaceBackgroundImageTile(const bool val) {
    if(val != m_interfaceBackgroundImageTile) {
        m_interfaceBackgroundImageTile = val;
        Q_EMIT interfaceBackgroundImageTileChanged();
    }
}

const bool PQCSettings::getDefaultForInterfaceBackgroundImageTile() const {
        return false;
}

void PQCSettings::setDefaultForInterfaceBackgroundImageTile() {
    if(false != m_interfaceBackgroundImageTile) {
        m_interfaceBackgroundImageTile = false;
        Q_EMIT interfaceBackgroundImageTileChanged();
    }
}

bool PQCSettings::getInterfaceBackgroundImageUse() const {
    return m_interfaceBackgroundImageUse;
}

void PQCSettings::setInterfaceBackgroundImageUse(const bool val) {
    if(val != m_interfaceBackgroundImageUse) {
        m_interfaceBackgroundImageUse = val;
        Q_EMIT interfaceBackgroundImageUseChanged();
    }
}

const bool PQCSettings::getDefaultForInterfaceBackgroundImageUse() const {
        return false;
}

void PQCSettings::setDefaultForInterfaceBackgroundImageUse() {
    if(false != m_interfaceBackgroundImageUse) {
        m_interfaceBackgroundImageUse = false;
        Q_EMIT interfaceBackgroundImageUseChanged();
    }
}

bool PQCSettings::getInterfaceBackgroundSolid() const {
    return m_interfaceBackgroundSolid;
}

void PQCSettings::setInterfaceBackgroundSolid(const bool val) {
    if(val != m_interfaceBackgroundSolid) {
        m_interfaceBackgroundSolid = val;
        Q_EMIT interfaceBackgroundSolidChanged();
    }
}

const bool PQCSettings::getDefaultForInterfaceBackgroundSolid() const {
        return false;
}

void PQCSettings::setDefaultForInterfaceBackgroundSolid() {
    if(false != m_interfaceBackgroundSolid) {
        m_interfaceBackgroundSolid = false;
        Q_EMIT interfaceBackgroundSolidChanged();
    }
}

bool PQCSettings::getInterfaceBlurElementsInBackground() const {
    return m_interfaceBlurElementsInBackground;
}

void PQCSettings::setInterfaceBlurElementsInBackground(const bool val) {
    if(val != m_interfaceBlurElementsInBackground) {
        m_interfaceBlurElementsInBackground = val;
        Q_EMIT interfaceBlurElementsInBackgroundChanged();
    }
}

const bool PQCSettings::getDefaultForInterfaceBlurElementsInBackground() const {
        return true;
}

void PQCSettings::setDefaultForInterfaceBlurElementsInBackground() {
    if(true != m_interfaceBlurElementsInBackground) {
        m_interfaceBlurElementsInBackground = true;
        Q_EMIT interfaceBlurElementsInBackgroundChanged();
    }
}

bool PQCSettings::getInterfaceCloseOnEmptyBackground() const {
    return m_interfaceCloseOnEmptyBackground;
}

void PQCSettings::setInterfaceCloseOnEmptyBackground(const bool val) {
    if(val != m_interfaceCloseOnEmptyBackground) {
        m_interfaceCloseOnEmptyBackground = val;
        Q_EMIT interfaceCloseOnEmptyBackgroundChanged();
    }
}

const bool PQCSettings::getDefaultForInterfaceCloseOnEmptyBackground() const {
        return false;
}

void PQCSettings::setDefaultForInterfaceCloseOnEmptyBackground() {
    if(false != m_interfaceCloseOnEmptyBackground) {
        m_interfaceCloseOnEmptyBackground = false;
        Q_EMIT interfaceCloseOnEmptyBackgroundChanged();
    }
}

int PQCSettings::getInterfaceDoubleClickThreshold() const {
    return m_interfaceDoubleClickThreshold;
}

void PQCSettings::setInterfaceDoubleClickThreshold(const int val) {
    if(val != m_interfaceDoubleClickThreshold) {
        m_interfaceDoubleClickThreshold = val;
        Q_EMIT interfaceDoubleClickThresholdChanged();
    }
}

const int PQCSettings::getDefaultForInterfaceDoubleClickThreshold() const {
        return 300;
}

void PQCSettings::setDefaultForInterfaceDoubleClickThreshold() {
    if(300 != m_interfaceDoubleClickThreshold) {
        m_interfaceDoubleClickThreshold = 300;
    }
}

QString PQCSettings::getInterfaceEdgeBottomAction() const {
    return m_interfaceEdgeBottomAction;
}

void PQCSettings::setInterfaceEdgeBottomAction(const QString val) {
    if(val != m_interfaceEdgeBottomAction) {
        m_interfaceEdgeBottomAction = val;
        Q_EMIT interfaceEdgeBottomActionChanged();
    }
}

const QString PQCSettings::getDefaultForInterfaceEdgeBottomAction() const {
        return "thumbnails";
}

void PQCSettings::setDefaultForInterfaceEdgeBottomAction() {
    if("thumbnails" != m_interfaceEdgeBottomAction) {
        m_interfaceEdgeBottomAction = "thumbnails";
        Q_EMIT interfaceEdgeBottomActionChanged();
    }
}

QString PQCSettings::getInterfaceEdgeLeftAction() const {
    return m_interfaceEdgeLeftAction;
}

void PQCSettings::setInterfaceEdgeLeftAction(const QString val) {
    if(val != m_interfaceEdgeLeftAction) {
        m_interfaceEdgeLeftAction = val;
        Q_EMIT interfaceEdgeLeftActionChanged();
    }
}

const QString PQCSettings::getDefaultForInterfaceEdgeLeftAction() const {
        return "metadata";
}

void PQCSettings::setDefaultForInterfaceEdgeLeftAction() {
    if("metadata" != m_interfaceEdgeLeftAction) {
        m_interfaceEdgeLeftAction = "metadata";
        Q_EMIT interfaceEdgeLeftActionChanged();
    }
}

QString PQCSettings::getInterfaceEdgeRightAction() const {
    return m_interfaceEdgeRightAction;
}

void PQCSettings::setInterfaceEdgeRightAction(const QString val) {
    if(val != m_interfaceEdgeRightAction) {
        m_interfaceEdgeRightAction = val;
        Q_EMIT interfaceEdgeRightActionChanged();
    }
}

const QString PQCSettings::getDefaultForInterfaceEdgeRightAction() const {
        return "mainmenu";
}

void PQCSettings::setDefaultForInterfaceEdgeRightAction() {
    if("mainmenu" != m_interfaceEdgeRightAction) {
        m_interfaceEdgeRightAction = "mainmenu";
        Q_EMIT interfaceEdgeRightActionChanged();
    }
}

QString PQCSettings::getInterfaceEdgeTopAction() const {
    return m_interfaceEdgeTopAction;
}

void PQCSettings::setInterfaceEdgeTopAction(const QString val) {
    if(val != m_interfaceEdgeTopAction) {
        m_interfaceEdgeTopAction = val;
        Q_EMIT interfaceEdgeTopActionChanged();
    }
}

const QString PQCSettings::getDefaultForInterfaceEdgeTopAction() const {
        return "";
}

void PQCSettings::setDefaultForInterfaceEdgeTopAction() {
    if("" != m_interfaceEdgeTopAction) {
        m_interfaceEdgeTopAction = "";
        Q_EMIT interfaceEdgeTopActionChanged();
    }
}

bool PQCSettings::getInterfaceFlickAdjustSpeed() const {
    return m_interfaceFlickAdjustSpeed;
}

void PQCSettings::setInterfaceFlickAdjustSpeed(const bool val) {
    if(val != m_interfaceFlickAdjustSpeed) {
        m_interfaceFlickAdjustSpeed = val;
        Q_EMIT interfaceFlickAdjustSpeedChanged();
    }
}

const bool PQCSettings::getDefaultForInterfaceFlickAdjustSpeed() const {
        return true;
}

void PQCSettings::setDefaultForInterfaceFlickAdjustSpeed() {
    if(true != m_interfaceFlickAdjustSpeed) {
        m_interfaceFlickAdjustSpeed = true;
        Q_EMIT interfaceFlickAdjustSpeedChanged();
    }
}

int PQCSettings::getInterfaceFlickAdjustSpeedSpeedup() const {
    return m_interfaceFlickAdjustSpeedSpeedup;
}

void PQCSettings::setInterfaceFlickAdjustSpeedSpeedup(const int val) {
    if(val != m_interfaceFlickAdjustSpeedSpeedup) {
        m_interfaceFlickAdjustSpeedSpeedup = val;
        Q_EMIT interfaceFlickAdjustSpeedSpeedupChanged();
    }
}

const int PQCSettings::getDefaultForInterfaceFlickAdjustSpeedSpeedup() const {
        return 1;
}

void PQCSettings::setDefaultForInterfaceFlickAdjustSpeedSpeedup() {
    if(1 != m_interfaceFlickAdjustSpeedSpeedup) {
        m_interfaceFlickAdjustSpeedSpeedup = 1;
    }
}

int PQCSettings::getInterfaceFontBoldWeight() const {
    return m_interfaceFontBoldWeight;
}

void PQCSettings::setInterfaceFontBoldWeight(const int val) {
    if(val != m_interfaceFontBoldWeight) {
        m_interfaceFontBoldWeight = val;
        Q_EMIT interfaceFontBoldWeightChanged();
    }
}

const int PQCSettings::getDefaultForInterfaceFontBoldWeight() const {
        return 700;
}

void PQCSettings::setDefaultForInterfaceFontBoldWeight() {
    if(700 != m_interfaceFontBoldWeight) {
        m_interfaceFontBoldWeight = 700;
    }
}

int PQCSettings::getInterfaceFontNormalWeight() const {
    return m_interfaceFontNormalWeight;
}

void PQCSettings::setInterfaceFontNormalWeight(const int val) {
    if(val != m_interfaceFontNormalWeight) {
        m_interfaceFontNormalWeight = val;
        Q_EMIT interfaceFontNormalWeightChanged();
    }
}

const int PQCSettings::getDefaultForInterfaceFontNormalWeight() const {
        return 400;
}

void PQCSettings::setDefaultForInterfaceFontNormalWeight() {
    if(400 != m_interfaceFontNormalWeight) {
        m_interfaceFontNormalWeight = 400;
    }
}

int PQCSettings::getInterfaceHotEdgeSize() const {
    return m_interfaceHotEdgeSize;
}

void PQCSettings::setInterfaceHotEdgeSize(const int val) {
    if(val != m_interfaceHotEdgeSize) {
        m_interfaceHotEdgeSize = val;
        Q_EMIT interfaceHotEdgeSizeChanged();
    }
}

const int PQCSettings::getDefaultForInterfaceHotEdgeSize() const {
        return 4;
}

void PQCSettings::setDefaultForInterfaceHotEdgeSize() {
    if(4 != m_interfaceHotEdgeSize) {
        m_interfaceHotEdgeSize = 4;
    }
}

bool PQCSettings::getInterfaceKeepWindowOnTop() const {
    return m_interfaceKeepWindowOnTop;
}

void PQCSettings::setInterfaceKeepWindowOnTop(const bool val) {
    if(val != m_interfaceKeepWindowOnTop) {
        m_interfaceKeepWindowOnTop = val;
        Q_EMIT interfaceKeepWindowOnTopChanged();
    }
}

const bool PQCSettings::getDefaultForInterfaceKeepWindowOnTop() const {
        return false;
}

void PQCSettings::setDefaultForInterfaceKeepWindowOnTop() {
    if(false != m_interfaceKeepWindowOnTop) {
        m_interfaceKeepWindowOnTop = false;
        Q_EMIT interfaceKeepWindowOnTopChanged();
    }
}

QString PQCSettings::getInterfaceLanguage() const {
    return m_interfaceLanguage;
}

void PQCSettings::setInterfaceLanguage(const QString val) {
    if(val != m_interfaceLanguage) {
        m_interfaceLanguage = val;
        Q_EMIT interfaceLanguageChanged();
    }
}

const QString PQCSettings::getDefaultForInterfaceLanguage() const {
        return "en";
}

void PQCSettings::setDefaultForInterfaceLanguage() {
    if("en" != m_interfaceLanguage) {
        m_interfaceLanguage = "en";
        Q_EMIT interfaceLanguageChanged();
    }
}

bool PQCSettings::getInterfaceMinimapPopout() const {
    return m_interfaceMinimapPopout;
}

void PQCSettings::setInterfaceMinimapPopout(const bool val) {
    if(val != m_interfaceMinimapPopout) {
        m_interfaceMinimapPopout = val;
        Q_EMIT interfaceMinimapPopoutChanged();
    }
}

const bool PQCSettings::getDefaultForInterfaceMinimapPopout() const {
        return false;
}

void PQCSettings::setDefaultForInterfaceMinimapPopout() {
    if(false != m_interfaceMinimapPopout) {
        m_interfaceMinimapPopout = false;
        Q_EMIT interfaceMinimapPopoutChanged();
    }
}

bool PQCSettings::getInterfaceNavigateOnEmptyBackground() const {
    return m_interfaceNavigateOnEmptyBackground;
}

void PQCSettings::setInterfaceNavigateOnEmptyBackground(const bool val) {
    if(val != m_interfaceNavigateOnEmptyBackground) {
        m_interfaceNavigateOnEmptyBackground = val;
        Q_EMIT interfaceNavigateOnEmptyBackgroundChanged();
    }
}

const bool PQCSettings::getDefaultForInterfaceNavigateOnEmptyBackground() const {
        return false;
}

void PQCSettings::setDefaultForInterfaceNavigateOnEmptyBackground() {
    if(false != m_interfaceNavigateOnEmptyBackground) {
        m_interfaceNavigateOnEmptyBackground = false;
        Q_EMIT interfaceNavigateOnEmptyBackgroundChanged();
    }
}

bool PQCSettings::getInterfaceNavigationFloating() const {
    return m_interfaceNavigationFloating;
}

void PQCSettings::setInterfaceNavigationFloating(const bool val) {
    if(val != m_interfaceNavigationFloating) {
        m_interfaceNavigationFloating = val;
        Q_EMIT interfaceNavigationFloatingChanged();
    }
}

const bool PQCSettings::getDefaultForInterfaceNavigationFloating() const {
        return false;
}

void PQCSettings::setDefaultForInterfaceNavigationFloating() {
    if(false != m_interfaceNavigationFloating) {
        m_interfaceNavigationFloating = false;
        Q_EMIT interfaceNavigationFloatingChanged();
    }
}

int PQCSettings::getInterfaceNotificationDistanceFromEdge() const {
    return m_interfaceNotificationDistanceFromEdge;
}

void PQCSettings::setInterfaceNotificationDistanceFromEdge(const int val) {
    if(val != m_interfaceNotificationDistanceFromEdge) {
        m_interfaceNotificationDistanceFromEdge = val;
        Q_EMIT interfaceNotificationDistanceFromEdgeChanged();
    }
}

const int PQCSettings::getDefaultForInterfaceNotificationDistanceFromEdge() const {
        return 40;
}

void PQCSettings::setDefaultForInterfaceNotificationDistanceFromEdge() {
    if(40 != m_interfaceNotificationDistanceFromEdge) {
        m_interfaceNotificationDistanceFromEdge = 40;
    }
}

QString PQCSettings::getInterfaceNotificationLocation() const {
    return m_interfaceNotificationLocation;
}

void PQCSettings::setInterfaceNotificationLocation(const QString val) {
    if(val != m_interfaceNotificationLocation) {
        m_interfaceNotificationLocation = val;
        Q_EMIT interfaceNotificationLocationChanged();
    }
}

const QString PQCSettings::getDefaultForInterfaceNotificationLocation() const {
        return "center";
}

void PQCSettings::setDefaultForInterfaceNotificationLocation() {
    if("center" != m_interfaceNotificationLocation) {
        m_interfaceNotificationLocation = "center";
        Q_EMIT interfaceNotificationLocationChanged();
    }
}

bool PQCSettings::getInterfaceNotificationTryNative() const {
    return m_interfaceNotificationTryNative;
}

void PQCSettings::setInterfaceNotificationTryNative(const bool val) {
    if(val != m_interfaceNotificationTryNative) {
        m_interfaceNotificationTryNative = val;
        Q_EMIT interfaceNotificationTryNativeChanged();
    }
}

const bool PQCSettings::getDefaultForInterfaceNotificationTryNative() const {
        return true;
}

void PQCSettings::setDefaultForInterfaceNotificationTryNative() {
    if(true != m_interfaceNotificationTryNative) {
        m_interfaceNotificationTryNative = true;
        Q_EMIT interfaceNotificationTryNativeChanged();
    }
}

bool PQCSettings::getInterfacePopoutAbout() const {
    return m_interfacePopoutAbout;
}

void PQCSettings::setInterfacePopoutAbout(const bool val) {
    if(val != m_interfacePopoutAbout) {
        m_interfacePopoutAbout = val;
        Q_EMIT interfacePopoutAboutChanged();
    }
}

const bool PQCSettings::getDefaultForInterfacePopoutAbout() const {
        return false;
}

void PQCSettings::setDefaultForInterfacePopoutAbout() {
    if(false != m_interfacePopoutAbout) {
        m_interfacePopoutAbout = false;
        Q_EMIT interfacePopoutAboutChanged();
    }
}

bool PQCSettings::getInterfacePopoutAdvancedSort() const {
    return m_interfacePopoutAdvancedSort;
}

void PQCSettings::setInterfacePopoutAdvancedSort(const bool val) {
    if(val != m_interfacePopoutAdvancedSort) {
        m_interfacePopoutAdvancedSort = val;
        Q_EMIT interfacePopoutAdvancedSortChanged();
    }
}

const bool PQCSettings::getDefaultForInterfacePopoutAdvancedSort() const {
        return true;
}

void PQCSettings::setDefaultForInterfacePopoutAdvancedSort() {
    if(true != m_interfacePopoutAdvancedSort) {
        m_interfacePopoutAdvancedSort = true;
        Q_EMIT interfacePopoutAdvancedSortChanged();
    }
}

bool PQCSettings::getInterfacePopoutChromecast() const {
    return m_interfacePopoutChromecast;
}

void PQCSettings::setInterfacePopoutChromecast(const bool val) {
    if(val != m_interfacePopoutChromecast) {
        m_interfacePopoutChromecast = val;
        Q_EMIT interfacePopoutChromecastChanged();
    }
}

const bool PQCSettings::getDefaultForInterfacePopoutChromecast() const {
        return true;
}

void PQCSettings::setDefaultForInterfacePopoutChromecast() {
    if(true != m_interfacePopoutChromecast) {
        m_interfacePopoutChromecast = true;
        Q_EMIT interfacePopoutChromecastChanged();
    }
}

bool PQCSettings::getInterfacePopoutExport() const {
    return m_interfacePopoutExport;
}

void PQCSettings::setInterfacePopoutExport(const bool val) {
    if(val != m_interfacePopoutExport) {
        m_interfacePopoutExport = val;
        Q_EMIT interfacePopoutExportChanged();
    }
}

const bool PQCSettings::getDefaultForInterfacePopoutExport() const {
        return true;
}

void PQCSettings::setDefaultForInterfacePopoutExport() {
    if(true != m_interfacePopoutExport) {
        m_interfacePopoutExport = true;
        Q_EMIT interfacePopoutExportChanged();
    }
}

bool PQCSettings::getInterfacePopoutFileDelete() const {
    return m_interfacePopoutFileDelete;
}

void PQCSettings::setInterfacePopoutFileDelete(const bool val) {
    if(val != m_interfacePopoutFileDelete) {
        m_interfacePopoutFileDelete = val;
        Q_EMIT interfacePopoutFileDeleteChanged();
    }
}

const bool PQCSettings::getDefaultForInterfacePopoutFileDelete() const {
        return false;
}

void PQCSettings::setDefaultForInterfacePopoutFileDelete() {
    if(false != m_interfacePopoutFileDelete) {
        m_interfacePopoutFileDelete = false;
        Q_EMIT interfacePopoutFileDeleteChanged();
    }
}

bool PQCSettings::getInterfacePopoutFileDialog() const {
    return m_interfacePopoutFileDialog;
}

void PQCSettings::setInterfacePopoutFileDialog(const bool val) {
    if(val != m_interfacePopoutFileDialog) {
        m_interfacePopoutFileDialog = val;
        Q_EMIT interfacePopoutFileDialogChanged();
    }
}

const bool PQCSettings::getDefaultForInterfacePopoutFileDialog() const {
        return false;
}

void PQCSettings::setDefaultForInterfacePopoutFileDialog() {
    if(false != m_interfacePopoutFileDialog) {
        m_interfacePopoutFileDialog = false;
        Q_EMIT interfacePopoutFileDialogChanged();
    }
}

bool PQCSettings::getInterfacePopoutFileDialogNonModal() const {
    return m_interfacePopoutFileDialogNonModal;
}

void PQCSettings::setInterfacePopoutFileDialogNonModal(const bool val) {
    if(val != m_interfacePopoutFileDialogNonModal) {
        m_interfacePopoutFileDialogNonModal = val;
        Q_EMIT interfacePopoutFileDialogNonModalChanged();
    }
}

const bool PQCSettings::getDefaultForInterfacePopoutFileDialogNonModal() const {
        return false;
}

void PQCSettings::setDefaultForInterfacePopoutFileDialogNonModal() {
    if(false != m_interfacePopoutFileDialogNonModal) {
        m_interfacePopoutFileDialogNonModal = false;
        Q_EMIT interfacePopoutFileDialogNonModalChanged();
    }
}

bool PQCSettings::getInterfacePopoutFileRename() const {
    return m_interfacePopoutFileRename;
}

void PQCSettings::setInterfacePopoutFileRename(const bool val) {
    if(val != m_interfacePopoutFileRename) {
        m_interfacePopoutFileRename = val;
        Q_EMIT interfacePopoutFileRenameChanged();
    }
}

const bool PQCSettings::getDefaultForInterfacePopoutFileRename() const {
        return false;
}

void PQCSettings::setDefaultForInterfacePopoutFileRename() {
    if(false != m_interfacePopoutFileRename) {
        m_interfacePopoutFileRename = false;
        Q_EMIT interfacePopoutFileRenameChanged();
    }
}

bool PQCSettings::getInterfacePopoutFilter() const {
    return m_interfacePopoutFilter;
}

void PQCSettings::setInterfacePopoutFilter(const bool val) {
    if(val != m_interfacePopoutFilter) {
        m_interfacePopoutFilter = val;
        Q_EMIT interfacePopoutFilterChanged();
    }
}

const bool PQCSettings::getDefaultForInterfacePopoutFilter() const {
        return false;
}

void PQCSettings::setDefaultForInterfacePopoutFilter() {
    if(false != m_interfacePopoutFilter) {
        m_interfacePopoutFilter = false;
        Q_EMIT interfacePopoutFilterChanged();
    }
}

bool PQCSettings::getInterfacePopoutFind() const {
    return m_interfacePopoutFind;
}

void PQCSettings::setInterfacePopoutFind(const bool val) {
    if(val != m_interfacePopoutFind) {
        m_interfacePopoutFind = val;
        Q_EMIT interfacePopoutFindChanged();
    }
}

const bool PQCSettings::getDefaultForInterfacePopoutFind() const {
        return false;
}

void PQCSettings::setDefaultForInterfacePopoutFind() {
    if(false != m_interfacePopoutFind) {
        m_interfacePopoutFind = false;
        Q_EMIT interfacePopoutFindChanged();
    }
}

bool PQCSettings::getInterfacePopoutImgur() const {
    return m_interfacePopoutImgur;
}

void PQCSettings::setInterfacePopoutImgur(const bool val) {
    if(val != m_interfacePopoutImgur) {
        m_interfacePopoutImgur = val;
        Q_EMIT interfacePopoutImgurChanged();
    }
}

const bool PQCSettings::getDefaultForInterfacePopoutImgur() const {
        return true;
}

void PQCSettings::setDefaultForInterfacePopoutImgur() {
    if(true != m_interfacePopoutImgur) {
        m_interfacePopoutImgur = true;
        Q_EMIT interfacePopoutImgurChanged();
    }
}

bool PQCSettings::getInterfacePopoutMainMenu() const {
    return m_interfacePopoutMainMenu;
}

void PQCSettings::setInterfacePopoutMainMenu(const bool val) {
    if(val != m_interfacePopoutMainMenu) {
        m_interfacePopoutMainMenu = val;
        Q_EMIT interfacePopoutMainMenuChanged();
    }
}

const bool PQCSettings::getDefaultForInterfacePopoutMainMenu() const {
        return false;
}

void PQCSettings::setDefaultForInterfacePopoutMainMenu() {
    if(false != m_interfacePopoutMainMenu) {
        m_interfacePopoutMainMenu = false;
        Q_EMIT interfacePopoutMainMenuChanged();
    }
}

bool PQCSettings::getInterfacePopoutMapExplorer() const {
    return m_interfacePopoutMapExplorer;
}

void PQCSettings::setInterfacePopoutMapExplorer(const bool val) {
    if(val != m_interfacePopoutMapExplorer) {
        m_interfacePopoutMapExplorer = val;
        Q_EMIT interfacePopoutMapExplorerChanged();
    }
}

const bool PQCSettings::getDefaultForInterfacePopoutMapExplorer() const {
        return true;
}

void PQCSettings::setDefaultForInterfacePopoutMapExplorer() {
    if(true != m_interfacePopoutMapExplorer) {
        m_interfacePopoutMapExplorer = true;
        Q_EMIT interfacePopoutMapExplorerChanged();
    }
}

bool PQCSettings::getInterfacePopoutMapExplorerNonModal() const {
    return m_interfacePopoutMapExplorerNonModal;
}

void PQCSettings::setInterfacePopoutMapExplorerNonModal(const bool val) {
    if(val != m_interfacePopoutMapExplorerNonModal) {
        m_interfacePopoutMapExplorerNonModal = val;
        Q_EMIT interfacePopoutMapExplorerNonModalChanged();
    }
}

const bool PQCSettings::getDefaultForInterfacePopoutMapExplorerNonModal() const {
        return false;
}

void PQCSettings::setDefaultForInterfacePopoutMapExplorerNonModal() {
    if(false != m_interfacePopoutMapExplorerNonModal) {
        m_interfacePopoutMapExplorerNonModal = false;
        Q_EMIT interfacePopoutMapExplorerNonModalChanged();
    }
}

bool PQCSettings::getInterfacePopoutMetadata() const {
    return m_interfacePopoutMetadata;
}

void PQCSettings::setInterfacePopoutMetadata(const bool val) {
    if(val != m_interfacePopoutMetadata) {
        m_interfacePopoutMetadata = val;
        Q_EMIT interfacePopoutMetadataChanged();
    }
}

const bool PQCSettings::getDefaultForInterfacePopoutMetadata() const {
        return false;
}

void PQCSettings::setDefaultForInterfacePopoutMetadata() {
    if(false != m_interfacePopoutMetadata) {
        m_interfacePopoutMetadata = false;
        Q_EMIT interfacePopoutMetadataChanged();
    }
}

bool PQCSettings::getInterfacePopoutSettingsManager() const {
    return m_interfacePopoutSettingsManager;
}

void PQCSettings::setInterfacePopoutSettingsManager(const bool val) {
    if(val != m_interfacePopoutSettingsManager) {
        m_interfacePopoutSettingsManager = val;
        Q_EMIT interfacePopoutSettingsManagerChanged();
    }
}

const bool PQCSettings::getDefaultForInterfacePopoutSettingsManager() const {
        return false;
}

void PQCSettings::setDefaultForInterfacePopoutSettingsManager() {
    if(false != m_interfacePopoutSettingsManager) {
        m_interfacePopoutSettingsManager = false;
        Q_EMIT interfacePopoutSettingsManagerChanged();
    }
}

bool PQCSettings::getInterfacePopoutSettingsManagerNonModal() const {
    return m_interfacePopoutSettingsManagerNonModal;
}

void PQCSettings::setInterfacePopoutSettingsManagerNonModal(const bool val) {
    if(val != m_interfacePopoutSettingsManagerNonModal) {
        m_interfacePopoutSettingsManagerNonModal = val;
        Q_EMIT interfacePopoutSettingsManagerNonModalChanged();
    }
}

const bool PQCSettings::getDefaultForInterfacePopoutSettingsManagerNonModal() const {
        return false;
}

void PQCSettings::setDefaultForInterfacePopoutSettingsManagerNonModal() {
    if(false != m_interfacePopoutSettingsManagerNonModal) {
        m_interfacePopoutSettingsManagerNonModal = false;
        Q_EMIT interfacePopoutSettingsManagerNonModalChanged();
    }
}

bool PQCSettings::getInterfacePopoutSlideshowControls() const {
    return m_interfacePopoutSlideshowControls;
}

void PQCSettings::setInterfacePopoutSlideshowControls(const bool val) {
    if(val != m_interfacePopoutSlideshowControls) {
        m_interfacePopoutSlideshowControls = val;
        Q_EMIT interfacePopoutSlideshowControlsChanged();
    }
}

const bool PQCSettings::getDefaultForInterfacePopoutSlideshowControls() const {
        return false;
}

void PQCSettings::setDefaultForInterfacePopoutSlideshowControls() {
    if(false != m_interfacePopoutSlideshowControls) {
        m_interfacePopoutSlideshowControls = false;
        Q_EMIT interfacePopoutSlideshowControlsChanged();
    }
}

bool PQCSettings::getInterfacePopoutSlideshowSetup() const {
    return m_interfacePopoutSlideshowSetup;
}

void PQCSettings::setInterfacePopoutSlideshowSetup(const bool val) {
    if(val != m_interfacePopoutSlideshowSetup) {
        m_interfacePopoutSlideshowSetup = val;
        Q_EMIT interfacePopoutSlideshowSetupChanged();
    }
}

const bool PQCSettings::getDefaultForInterfacePopoutSlideshowSetup() const {
        return true;
}

void PQCSettings::setDefaultForInterfacePopoutSlideshowSetup() {
    if(true != m_interfacePopoutSlideshowSetup) {
        m_interfacePopoutSlideshowSetup = true;
        Q_EMIT interfacePopoutSlideshowSetupChanged();
    }
}

bool PQCSettings::getInterfacePopoutWhenWindowIsSmall() const {
    return m_interfacePopoutWhenWindowIsSmall;
}

void PQCSettings::setInterfacePopoutWhenWindowIsSmall(const bool val) {
    if(val != m_interfacePopoutWhenWindowIsSmall) {
        m_interfacePopoutWhenWindowIsSmall = val;
        Q_EMIT interfacePopoutWhenWindowIsSmallChanged();
    }
}

const bool PQCSettings::getDefaultForInterfacePopoutWhenWindowIsSmall() const {
        return true;
}

void PQCSettings::setDefaultForInterfacePopoutWhenWindowIsSmall() {
    if(true != m_interfacePopoutWhenWindowIsSmall) {
        m_interfacePopoutWhenWindowIsSmall = true;
        Q_EMIT interfacePopoutWhenWindowIsSmallChanged();
    }
}

bool PQCSettings::getInterfaceQuickActions() const {
    return m_interfaceQuickActions;
}

void PQCSettings::setInterfaceQuickActions(const bool val) {
    if(val != m_interfaceQuickActions) {
        m_interfaceQuickActions = val;
        Q_EMIT interfaceQuickActionsChanged();
    }
}

const bool PQCSettings::getDefaultForInterfaceQuickActions() const {
        return false;
}

void PQCSettings::setDefaultForInterfaceQuickActions() {
    if(false != m_interfaceQuickActions) {
        m_interfaceQuickActions = false;
        Q_EMIT interfaceQuickActionsChanged();
    }
}

int PQCSettings::getInterfaceQuickActionsHeight() const {
    return m_interfaceQuickActionsHeight;
}

void PQCSettings::setInterfaceQuickActionsHeight(const int val) {
    if(val != m_interfaceQuickActionsHeight) {
        m_interfaceQuickActionsHeight = val;
        Q_EMIT interfaceQuickActionsHeightChanged();
    }
}

const int PQCSettings::getDefaultForInterfaceQuickActionsHeight() const {
        return 40;
}

void PQCSettings::setDefaultForInterfaceQuickActionsHeight() {
    if(40 != m_interfaceQuickActionsHeight) {
        m_interfaceQuickActionsHeight = 40;
    }
}

QStringList PQCSettings::getInterfaceQuickActionsItems() const {
    return m_interfaceQuickActionsItems;
}

void PQCSettings::setInterfaceQuickActionsItems(const QStringList val) {
    if(val != m_interfaceQuickActionsItems) {
        m_interfaceQuickActionsItems = val;
        Q_EMIT interfaceQuickActionsItemsChanged();
    }
}

const QStringList PQCSettings::getDefaultForInterfaceQuickActionsItems() const {
        return QStringList() << "rename" << "delete" << "|" << "rotateleft" << "rotateright" << "mirrorhor" << "mirrorver" << "|" << "crop" << "scale" << "|" << "close";
}

void PQCSettings::setDefaultForInterfaceQuickActionsItems() {
    QStringList tmp = QStringList() << "rename" << "delete" << "|" << "rotateleft" << "rotateright" << "mirrorhor" << "mirrorver" << "|" << "crop" << "scale" << "|" << "close";
    if(tmp != m_interfaceQuickActionsItems) {
        m_interfaceQuickActionsItems = tmp;
        Q_EMIT interfaceQuickActionsItemsChanged();
    }
}

bool PQCSettings::getInterfaceRememberLastImage() const {
    return m_interfaceRememberLastImage;
}

void PQCSettings::setInterfaceRememberLastImage(const bool val) {
    if(val != m_interfaceRememberLastImage) {
        m_interfaceRememberLastImage = val;
        Q_EMIT interfaceRememberLastImageChanged();
    }
}

const bool PQCSettings::getDefaultForInterfaceRememberLastImage() const {
        return false;
}

void PQCSettings::setDefaultForInterfaceRememberLastImage() {
    if(false != m_interfaceRememberLastImage) {
        m_interfaceRememberLastImage = false;
        Q_EMIT interfaceRememberLastImageChanged();
    }
}

bool PQCSettings::getInterfaceSaveWindowGeometry() const {
    return m_interfaceSaveWindowGeometry;
}

void PQCSettings::setInterfaceSaveWindowGeometry(const bool val) {
    if(val != m_interfaceSaveWindowGeometry) {
        m_interfaceSaveWindowGeometry = val;
        Q_EMIT interfaceSaveWindowGeometryChanged();
    }
}

const bool PQCSettings::getDefaultForInterfaceSaveWindowGeometry() const {
        return false;
}

void PQCSettings::setDefaultForInterfaceSaveWindowGeometry() {
    if(false != m_interfaceSaveWindowGeometry) {
        m_interfaceSaveWindowGeometry = false;
        Q_EMIT interfaceSaveWindowGeometryChanged();
    }
}

bool PQCSettings::getInterfaceStatusInfoAutoHide() const {
    return m_interfaceStatusInfoAutoHide;
}

void PQCSettings::setInterfaceStatusInfoAutoHide(const bool val) {
    if(val != m_interfaceStatusInfoAutoHide) {
        m_interfaceStatusInfoAutoHide = val;
        Q_EMIT interfaceStatusInfoAutoHideChanged();
    }
}

const bool PQCSettings::getDefaultForInterfaceStatusInfoAutoHide() const {
        return false;
}

void PQCSettings::setDefaultForInterfaceStatusInfoAutoHide() {
    if(false != m_interfaceStatusInfoAutoHide) {
        m_interfaceStatusInfoAutoHide = false;
        Q_EMIT interfaceStatusInfoAutoHideChanged();
    }
}

int PQCSettings::getInterfaceStatusInfoAutoHideTimeout() const {
    return m_interfaceStatusInfoAutoHideTimeout;
}

void PQCSettings::setInterfaceStatusInfoAutoHideTimeout(const int val) {
    if(val != m_interfaceStatusInfoAutoHideTimeout) {
        m_interfaceStatusInfoAutoHideTimeout = val;
        Q_EMIT interfaceStatusInfoAutoHideTimeoutChanged();
    }
}

const int PQCSettings::getDefaultForInterfaceStatusInfoAutoHideTimeout() const {
        return 1000;
}

void PQCSettings::setDefaultForInterfaceStatusInfoAutoHideTimeout() {
    if(1000 != m_interfaceStatusInfoAutoHideTimeout) {
        m_interfaceStatusInfoAutoHideTimeout = 1000;
    }
}

bool PQCSettings::getInterfaceStatusInfoAutoHideTopEdge() const {
    return m_interfaceStatusInfoAutoHideTopEdge;
}

void PQCSettings::setInterfaceStatusInfoAutoHideTopEdge(const bool val) {
    if(val != m_interfaceStatusInfoAutoHideTopEdge) {
        m_interfaceStatusInfoAutoHideTopEdge = val;
        Q_EMIT interfaceStatusInfoAutoHideTopEdgeChanged();
    }
}

const bool PQCSettings::getDefaultForInterfaceStatusInfoAutoHideTopEdge() const {
        return false;
}

void PQCSettings::setDefaultForInterfaceStatusInfoAutoHideTopEdge() {
    if(false != m_interfaceStatusInfoAutoHideTopEdge) {
        m_interfaceStatusInfoAutoHideTopEdge = false;
        Q_EMIT interfaceStatusInfoAutoHideTopEdgeChanged();
    }
}

int PQCSettings::getInterfaceStatusInfoFontSize() const {
    return m_interfaceStatusInfoFontSize;
}

void PQCSettings::setInterfaceStatusInfoFontSize(const int val) {
    if(val != m_interfaceStatusInfoFontSize) {
        m_interfaceStatusInfoFontSize = val;
        Q_EMIT interfaceStatusInfoFontSizeChanged();
    }
}

const int PQCSettings::getDefaultForInterfaceStatusInfoFontSize() const {
        return 10;
}

void PQCSettings::setDefaultForInterfaceStatusInfoFontSize() {
    if(10 != m_interfaceStatusInfoFontSize) {
        m_interfaceStatusInfoFontSize = 10;
    }
}

QStringList PQCSettings::getInterfaceStatusInfoList() const {
    return m_interfaceStatusInfoList;
}

void PQCSettings::setInterfaceStatusInfoList(const QStringList val) {
    if(val != m_interfaceStatusInfoList) {
        m_interfaceStatusInfoList = val;
        Q_EMIT interfaceStatusInfoListChanged();
    }
}

const QStringList PQCSettings::getDefaultForInterfaceStatusInfoList() const {
        return QStringList() << "counter" << "filename" << "zoom" << "rotation";
}

void PQCSettings::setDefaultForInterfaceStatusInfoList() {
    QStringList tmp = QStringList() << "counter" << "filename" << "zoom" << "rotation";
    if(tmp != m_interfaceStatusInfoList) {
        m_interfaceStatusInfoList = tmp;
        Q_EMIT interfaceStatusInfoListChanged();
    }
}

bool PQCSettings::getInterfaceStatusInfoManageWindow() const {
    return m_interfaceStatusInfoManageWindow;
}

void PQCSettings::setInterfaceStatusInfoManageWindow(const bool val) {
    if(val != m_interfaceStatusInfoManageWindow) {
        m_interfaceStatusInfoManageWindow = val;
        Q_EMIT interfaceStatusInfoManageWindowChanged();
    }
}

const bool PQCSettings::getDefaultForInterfaceStatusInfoManageWindow() const {
        return false;
}

void PQCSettings::setDefaultForInterfaceStatusInfoManageWindow() {
    if(false != m_interfaceStatusInfoManageWindow) {
        m_interfaceStatusInfoManageWindow = false;
        Q_EMIT interfaceStatusInfoManageWindowChanged();
    }
}

QString PQCSettings::getInterfaceStatusInfoPosition() const {
    return m_interfaceStatusInfoPosition;
}

void PQCSettings::setInterfaceStatusInfoPosition(const QString val) {
    if(val != m_interfaceStatusInfoPosition) {
        m_interfaceStatusInfoPosition = val;
        Q_EMIT interfaceStatusInfoPositionChanged();
    }
}

const QString PQCSettings::getDefaultForInterfaceStatusInfoPosition() const {
        return "left";
}

void PQCSettings::setDefaultForInterfaceStatusInfoPosition() {
    if("left" != m_interfaceStatusInfoPosition) {
        m_interfaceStatusInfoPosition = "left";
        Q_EMIT interfaceStatusInfoPositionChanged();
    }
}

bool PQCSettings::getInterfaceStatusInfoShow() const {
    return m_interfaceStatusInfoShow;
}

void PQCSettings::setInterfaceStatusInfoShow(const bool val) {
    if(val != m_interfaceStatusInfoShow) {
        m_interfaceStatusInfoShow = val;
        Q_EMIT interfaceStatusInfoShowChanged();
    }
}

const bool PQCSettings::getDefaultForInterfaceStatusInfoShow() const {
        return true;
}

void PQCSettings::setDefaultForInterfaceStatusInfoShow() {
    if(true != m_interfaceStatusInfoShow) {
        m_interfaceStatusInfoShow = true;
        Q_EMIT interfaceStatusInfoShowChanged();
    }
}

bool PQCSettings::getInterfaceStatusInfoShowImageChange() const {
    return m_interfaceStatusInfoShowImageChange;
}

void PQCSettings::setInterfaceStatusInfoShowImageChange(const bool val) {
    if(val != m_interfaceStatusInfoShowImageChange) {
        m_interfaceStatusInfoShowImageChange = val;
        Q_EMIT interfaceStatusInfoShowImageChangeChanged();
    }
}

const bool PQCSettings::getDefaultForInterfaceStatusInfoShowImageChange() const {
        return true;
}

void PQCSettings::setDefaultForInterfaceStatusInfoShowImageChange() {
    if(true != m_interfaceStatusInfoShowImageChange) {
        m_interfaceStatusInfoShowImageChange = true;
        Q_EMIT interfaceStatusInfoShowImageChangeChanged();
    }
}

int PQCSettings::getInterfaceTrayIcon() const {
    return m_interfaceTrayIcon;
}

void PQCSettings::setInterfaceTrayIcon(const int val) {
    if(val != m_interfaceTrayIcon) {
        m_interfaceTrayIcon = val;
        Q_EMIT interfaceTrayIconChanged();
    }
}

const int PQCSettings::getDefaultForInterfaceTrayIcon() const {
        return 0;
}

void PQCSettings::setDefaultForInterfaceTrayIcon() {
    if(0 != m_interfaceTrayIcon) {
        m_interfaceTrayIcon = 0;
    }
}

bool PQCSettings::getInterfaceTrayIconHideReset() const {
    return m_interfaceTrayIconHideReset;
}

void PQCSettings::setInterfaceTrayIconHideReset(const bool val) {
    if(val != m_interfaceTrayIconHideReset) {
        m_interfaceTrayIconHideReset = val;
        Q_EMIT interfaceTrayIconHideResetChanged();
    }
}

const bool PQCSettings::getDefaultForInterfaceTrayIconHideReset() const {
        return false;
}

void PQCSettings::setDefaultForInterfaceTrayIconHideReset() {
    if(false != m_interfaceTrayIconHideReset) {
        m_interfaceTrayIconHideReset = false;
        Q_EMIT interfaceTrayIconHideResetChanged();
    }
}

bool PQCSettings::getInterfaceTrayIconMonochrome() const {
    return m_interfaceTrayIconMonochrome;
}

void PQCSettings::setInterfaceTrayIconMonochrome(const bool val) {
    if(val != m_interfaceTrayIconMonochrome) {
        m_interfaceTrayIconMonochrome = val;
        Q_EMIT interfaceTrayIconMonochromeChanged();
    }
}

const bool PQCSettings::getDefaultForInterfaceTrayIconMonochrome() const {
        return true;
}

void PQCSettings::setDefaultForInterfaceTrayIconMonochrome() {
    if(true != m_interfaceTrayIconMonochrome) {
        m_interfaceTrayIconMonochrome = true;
        Q_EMIT interfaceTrayIconMonochromeChanged();
    }
}

bool PQCSettings::getInterfaceWindowButtonsAutoHide() const {
    return m_interfaceWindowButtonsAutoHide;
}

void PQCSettings::setInterfaceWindowButtonsAutoHide(const bool val) {
    if(val != m_interfaceWindowButtonsAutoHide) {
        m_interfaceWindowButtonsAutoHide = val;
        Q_EMIT interfaceWindowButtonsAutoHideChanged();
    }
}

const bool PQCSettings::getDefaultForInterfaceWindowButtonsAutoHide() const {
        return false;
}

void PQCSettings::setDefaultForInterfaceWindowButtonsAutoHide() {
    if(false != m_interfaceWindowButtonsAutoHide) {
        m_interfaceWindowButtonsAutoHide = false;
        Q_EMIT interfaceWindowButtonsAutoHideChanged();
    }
}

int PQCSettings::getInterfaceWindowButtonsAutoHideTimeout() const {
    return m_interfaceWindowButtonsAutoHideTimeout;
}

void PQCSettings::setInterfaceWindowButtonsAutoHideTimeout(const int val) {
    if(val != m_interfaceWindowButtonsAutoHideTimeout) {
        m_interfaceWindowButtonsAutoHideTimeout = val;
        Q_EMIT interfaceWindowButtonsAutoHideTimeoutChanged();
    }
}

const int PQCSettings::getDefaultForInterfaceWindowButtonsAutoHideTimeout() const {
        return 1000;
}

void PQCSettings::setDefaultForInterfaceWindowButtonsAutoHideTimeout() {
    if(1000 != m_interfaceWindowButtonsAutoHideTimeout) {
        m_interfaceWindowButtonsAutoHideTimeout = 1000;
    }
}

bool PQCSettings::getInterfaceWindowButtonsAutoHideTopEdge() const {
    return m_interfaceWindowButtonsAutoHideTopEdge;
}

void PQCSettings::setInterfaceWindowButtonsAutoHideTopEdge(const bool val) {
    if(val != m_interfaceWindowButtonsAutoHideTopEdge) {
        m_interfaceWindowButtonsAutoHideTopEdge = val;
        Q_EMIT interfaceWindowButtonsAutoHideTopEdgeChanged();
    }
}

const bool PQCSettings::getDefaultForInterfaceWindowButtonsAutoHideTopEdge() const {
        return false;
}

void PQCSettings::setDefaultForInterfaceWindowButtonsAutoHideTopEdge() {
    if(false != m_interfaceWindowButtonsAutoHideTopEdge) {
        m_interfaceWindowButtonsAutoHideTopEdge = false;
        Q_EMIT interfaceWindowButtonsAutoHideTopEdgeChanged();
    }
}

bool PQCSettings::getInterfaceWindowButtonsFollowAccentColor() const {
    return m_interfaceWindowButtonsFollowAccentColor;
}

void PQCSettings::setInterfaceWindowButtonsFollowAccentColor(const bool val) {
    if(val != m_interfaceWindowButtonsFollowAccentColor) {
        m_interfaceWindowButtonsFollowAccentColor = val;
        Q_EMIT interfaceWindowButtonsFollowAccentColorChanged();
    }
}

const bool PQCSettings::getDefaultForInterfaceWindowButtonsFollowAccentColor() const {
        return false;
}

void PQCSettings::setDefaultForInterfaceWindowButtonsFollowAccentColor() {
    if(false != m_interfaceWindowButtonsFollowAccentColor) {
        m_interfaceWindowButtonsFollowAccentColor = false;
        Q_EMIT interfaceWindowButtonsFollowAccentColorChanged();
    }
}

QStringList PQCSettings::getInterfaceWindowButtonsItems() const {
    return m_interfaceWindowButtonsItems;
}

void PQCSettings::setInterfaceWindowButtonsItems(const QStringList val) {
    if(val != m_interfaceWindowButtonsItems) {
        m_interfaceWindowButtonsItems = val;
        Q_EMIT interfaceWindowButtonsItemsChanged();
    }
}

const QStringList PQCSettings::getDefaultForInterfaceWindowButtonsItems() const {
        return QStringList() << "left_0|0|0" << "right_0|0|0" << "menu_0|0|0" << "ontop_0|1|1" << "fullscreen_0|0|1";
}

void PQCSettings::setDefaultForInterfaceWindowButtonsItems() {
    QStringList tmp = QStringList() << "left_0|0|0" << "right_0|0|0" << "menu_0|0|0" << "ontop_0|1|1" << "fullscreen_0|0|1";
    if(tmp != m_interfaceWindowButtonsItems) {
        m_interfaceWindowButtonsItems = tmp;
        Q_EMIT interfaceWindowButtonsItemsChanged();
    }
}

bool PQCSettings::getInterfaceWindowButtonsShow() const {
    return m_interfaceWindowButtonsShow;
}

void PQCSettings::setInterfaceWindowButtonsShow(const bool val) {
    if(val != m_interfaceWindowButtonsShow) {
        m_interfaceWindowButtonsShow = val;
        Q_EMIT interfaceWindowButtonsShowChanged();
    }
}

const bool PQCSettings::getDefaultForInterfaceWindowButtonsShow() const {
        return true;
}

void PQCSettings::setDefaultForInterfaceWindowButtonsShow() {
    if(true != m_interfaceWindowButtonsShow) {
        m_interfaceWindowButtonsShow = true;
        Q_EMIT interfaceWindowButtonsShowChanged();
    }
}

int PQCSettings::getInterfaceWindowButtonsSize() const {
    return m_interfaceWindowButtonsSize;
}

void PQCSettings::setInterfaceWindowButtonsSize(const int val) {
    if(val != m_interfaceWindowButtonsSize) {
        m_interfaceWindowButtonsSize = val;
        Q_EMIT interfaceWindowButtonsSizeChanged();
    }
}

const int PQCSettings::getDefaultForInterfaceWindowButtonsSize() const {
        return 10;
}

void PQCSettings::setDefaultForInterfaceWindowButtonsSize() {
    if(10 != m_interfaceWindowButtonsSize) {
        m_interfaceWindowButtonsSize = 10;
    }
}

bool PQCSettings::getInterfaceWindowDecoration() const {
    return m_interfaceWindowDecoration;
}

void PQCSettings::setInterfaceWindowDecoration(const bool val) {
    if(val != m_interfaceWindowDecoration) {
        m_interfaceWindowDecoration = val;
        Q_EMIT interfaceWindowDecorationChanged();
    }
}

const bool PQCSettings::getDefaultForInterfaceWindowDecoration() const {
        return true;
}

void PQCSettings::setDefaultForInterfaceWindowDecoration() {
    if(true != m_interfaceWindowDecoration) {
        m_interfaceWindowDecoration = true;
        Q_EMIT interfaceWindowDecorationChanged();
    }
}

bool PQCSettings::getInterfaceWindowDecorationOnEmptyBackground() const {
    return m_interfaceWindowDecorationOnEmptyBackground;
}

void PQCSettings::setInterfaceWindowDecorationOnEmptyBackground(const bool val) {
    if(val != m_interfaceWindowDecorationOnEmptyBackground) {
        m_interfaceWindowDecorationOnEmptyBackground = val;
        Q_EMIT interfaceWindowDecorationOnEmptyBackgroundChanged();
    }
}

const bool PQCSettings::getDefaultForInterfaceWindowDecorationOnEmptyBackground() const {
        return false;
}

void PQCSettings::setDefaultForInterfaceWindowDecorationOnEmptyBackground() {
    if(false != m_interfaceWindowDecorationOnEmptyBackground) {
        m_interfaceWindowDecorationOnEmptyBackground = false;
        Q_EMIT interfaceWindowDecorationOnEmptyBackgroundChanged();
    }
}

bool PQCSettings::getInterfaceWindowMode() const {
    return m_interfaceWindowMode;
}

void PQCSettings::setInterfaceWindowMode(const bool val) {
    if(val != m_interfaceWindowMode) {
        m_interfaceWindowMode = val;
        Q_EMIT interfaceWindowModeChanged();
    }
}

const bool PQCSettings::getDefaultForInterfaceWindowMode() const {
        return true;
}

void PQCSettings::setDefaultForInterfaceWindowMode() {
    if(true != m_interfaceWindowMode) {
        m_interfaceWindowMode = true;
        Q_EMIT interfaceWindowModeChanged();
    }
}

bool PQCSettings::getMainmenuElementHeightDynamic() const {
    return m_mainmenuElementHeightDynamic;
}

void PQCSettings::setMainmenuElementHeightDynamic(const bool val) {
    if(val != m_mainmenuElementHeightDynamic) {
        m_mainmenuElementHeightDynamic = val;
        Q_EMIT mainmenuElementHeightDynamicChanged();
    }
}

const bool PQCSettings::getDefaultForMainmenuElementHeightDynamic() const {
        return true;
}

void PQCSettings::setDefaultForMainmenuElementHeightDynamic() {
    if(true != m_mainmenuElementHeightDynamic) {
        m_mainmenuElementHeightDynamic = true;
        Q_EMIT mainmenuElementHeightDynamicChanged();
    }
}

QPointF PQCSettings::getMainmenuElementPosition() const {
    return m_mainmenuElementPosition;
}

void PQCSettings::setMainmenuElementPosition(const QPointF val) {
    if(val != m_mainmenuElementPosition) {
        m_mainmenuElementPosition = val;
        Q_EMIT mainmenuElementPositionChanged();
    }
}

const QPointF PQCSettings::getDefaultForMainmenuElementPosition() const {
        return QPointF(100, 100);
}

void PQCSettings::setDefaultForMainmenuElementPosition() {
    if(QPointF(100, 100) != m_mainmenuElementPosition) {
        m_mainmenuElementPosition = QPointF(100, 100);
        Q_EMIT mainmenuElementPositionChanged();
    }
}

QSizeF PQCSettings::getMainmenuElementSize() const {
    return m_mainmenuElementSize;
}

void PQCSettings::setMainmenuElementSize(const QSizeF val) {
    if(val != m_mainmenuElementSize) {
        m_mainmenuElementSize = val;
        Q_EMIT mainmenuElementSizeChanged();
    }
}

const QSizeF PQCSettings::getDefaultForMainmenuElementSize() const {
        return QSize(450, 900);
}

void PQCSettings::setDefaultForMainmenuElementSize() {
    if(QSize(450, 900) != m_mainmenuElementSize) {
        m_mainmenuElementSize = QSize(450, 900);
        Q_EMIT mainmenuElementSizeChanged();
    }
}

int PQCSettings::getMainmenuElementWidth() const {
    return m_mainmenuElementWidth;
}

void PQCSettings::setMainmenuElementWidth(const int val) {
    if(val != m_mainmenuElementWidth) {
        m_mainmenuElementWidth = val;
        Q_EMIT mainmenuElementWidthChanged();
    }
}

const int PQCSettings::getDefaultForMainmenuElementWidth() const {
        return 450;
}

void PQCSettings::setDefaultForMainmenuElementWidth() {
    if(450 != m_mainmenuElementWidth) {
        m_mainmenuElementWidth = 450;
    }
}

bool PQCSettings::getMainmenuShowExternal() const {
    return m_mainmenuShowExternal;
}

void PQCSettings::setMainmenuShowExternal(const bool val) {
    if(val != m_mainmenuShowExternal) {
        m_mainmenuShowExternal = val;
        Q_EMIT mainmenuShowExternalChanged();
    }
}

const bool PQCSettings::getDefaultForMainmenuShowExternal() const {
        return false;
}

void PQCSettings::setDefaultForMainmenuShowExternal() {
    if(false != m_mainmenuShowExternal) {
        m_mainmenuShowExternal = false;
        Q_EMIT mainmenuShowExternalChanged();
    }
}

QPointF PQCSettings::getMapviewCurrentPosition() const {
    return m_mapviewCurrentPosition;
}

void PQCSettings::setMapviewCurrentPosition(const QPointF val) {
    if(val != m_mapviewCurrentPosition) {
        m_mapviewCurrentPosition = val;
        Q_EMIT mapviewCurrentPositionChanged();
    }
}

const QPointF PQCSettings::getDefaultForMapviewCurrentPosition() const {
        return QPointF(200, 200);
}

void PQCSettings::setDefaultForMapviewCurrentPosition() {
    if(QPointF(200, 200) != m_mapviewCurrentPosition) {
        m_mapviewCurrentPosition = QPointF(200, 200);
        Q_EMIT mapviewCurrentPositionChanged();
    }
}

QSizeF PQCSettings::getMapviewCurrentSize() const {
    return m_mapviewCurrentSize;
}

void PQCSettings::setMapviewCurrentSize(const QSizeF val) {
    if(val != m_mapviewCurrentSize) {
        m_mapviewCurrentSize = val;
        Q_EMIT mapviewCurrentSizeChanged();
    }
}

const QSizeF PQCSettings::getDefaultForMapviewCurrentSize() const {
        return QSize(400, 300);
}

void PQCSettings::setDefaultForMapviewCurrentSize() {
    if(QSize(400, 300) != m_mapviewCurrentSize) {
        m_mapviewCurrentSize = QSize(400, 300);
        Q_EMIT mapviewCurrentSizeChanged();
    }
}

bool PQCSettings::getMapviewCurrentVisible() const {
    return m_mapviewCurrentVisible;
}

void PQCSettings::setMapviewCurrentVisible(const bool val) {
    if(val != m_mapviewCurrentVisible) {
        m_mapviewCurrentVisible = val;
        Q_EMIT mapviewCurrentVisibleChanged();
    }
}

const bool PQCSettings::getDefaultForMapviewCurrentVisible() const {
        return false;
}

void PQCSettings::setDefaultForMapviewCurrentVisible() {
    if(false != m_mapviewCurrentVisible) {
        m_mapviewCurrentVisible = false;
        Q_EMIT mapviewCurrentVisibleChanged();
    }
}

bool PQCSettings::getMapviewExplorerThumbnailsScaleCrop() const {
    return m_mapviewExplorerThumbnailsScaleCrop;
}

void PQCSettings::setMapviewExplorerThumbnailsScaleCrop(const bool val) {
    if(val != m_mapviewExplorerThumbnailsScaleCrop) {
        m_mapviewExplorerThumbnailsScaleCrop = val;
        Q_EMIT mapviewExplorerThumbnailsScaleCropChanged();
    }
}

const bool PQCSettings::getDefaultForMapviewExplorerThumbnailsScaleCrop() const {
        return true;
}

void PQCSettings::setDefaultForMapviewExplorerThumbnailsScaleCrop() {
    if(true != m_mapviewExplorerThumbnailsScaleCrop) {
        m_mapviewExplorerThumbnailsScaleCrop = true;
        Q_EMIT mapviewExplorerThumbnailsScaleCropChanged();
    }
}

int PQCSettings::getMapviewExplorerThumbnailsZoomLevel() const {
    return m_mapviewExplorerThumbnailsZoomLevel;
}

void PQCSettings::setMapviewExplorerThumbnailsZoomLevel(const int val) {
    if(val != m_mapviewExplorerThumbnailsZoomLevel) {
        m_mapviewExplorerThumbnailsZoomLevel = val;
        Q_EMIT mapviewExplorerThumbnailsZoomLevelChanged();
    }
}

const int PQCSettings::getDefaultForMapviewExplorerThumbnailsZoomLevel() const {
        return 20;
}

void PQCSettings::setDefaultForMapviewExplorerThumbnailsZoomLevel() {
    if(20 != m_mapviewExplorerThumbnailsZoomLevel) {
        m_mapviewExplorerThumbnailsZoomLevel = 20;
    }
}

bool PQCSettings::getMetadataAutoRotation() const {
    return m_metadataAutoRotation;
}

void PQCSettings::setMetadataAutoRotation(const bool val) {
    if(val != m_metadataAutoRotation) {
        m_metadataAutoRotation = val;
        Q_EMIT metadataAutoRotationChanged();
    }
}

const bool PQCSettings::getDefaultForMetadataAutoRotation() const {
        return true;
}

void PQCSettings::setDefaultForMetadataAutoRotation() {
    if(true != m_metadataAutoRotation) {
        m_metadataAutoRotation = true;
        Q_EMIT metadataAutoRotationChanged();
    }
}

bool PQCSettings::getMetadataCopyright() const {
    return m_metadataCopyright;
}

void PQCSettings::setMetadataCopyright(const bool val) {
    if(val != m_metadataCopyright) {
        m_metadataCopyright = val;
        Q_EMIT metadataCopyrightChanged();
    }
}

const bool PQCSettings::getDefaultForMetadataCopyright() const {
        return false;
}

void PQCSettings::setDefaultForMetadataCopyright() {
    if(false != m_metadataCopyright) {
        m_metadataCopyright = false;
        Q_EMIT metadataCopyrightChanged();
    }
}

bool PQCSettings::getMetadataDimensions() const {
    return m_metadataDimensions;
}

void PQCSettings::setMetadataDimensions(const bool val) {
    if(val != m_metadataDimensions) {
        m_metadataDimensions = val;
        Q_EMIT metadataDimensionsChanged();
    }
}

const bool PQCSettings::getDefaultForMetadataDimensions() const {
        return true;
}

void PQCSettings::setDefaultForMetadataDimensions() {
    if(true != m_metadataDimensions) {
        m_metadataDimensions = true;
        Q_EMIT metadataDimensionsChanged();
    }
}

bool PQCSettings::getMetadataElementFloating() const {
    return m_metadataElementFloating;
}

void PQCSettings::setMetadataElementFloating(const bool val) {
    if(val != m_metadataElementFloating) {
        m_metadataElementFloating = val;
        Q_EMIT metadataElementFloatingChanged();
    }
}

const bool PQCSettings::getDefaultForMetadataElementFloating() const {
        return false;
}

void PQCSettings::setDefaultForMetadataElementFloating() {
    if(false != m_metadataElementFloating) {
        m_metadataElementFloating = false;
        Q_EMIT metadataElementFloatingChanged();
    }
}

bool PQCSettings::getMetadataElementHeightDynamic() const {
    return m_metadataElementHeightDynamic;
}

void PQCSettings::setMetadataElementHeightDynamic(const bool val) {
    if(val != m_metadataElementHeightDynamic) {
        m_metadataElementHeightDynamic = val;
        Q_EMIT metadataElementHeightDynamicChanged();
    }
}

const bool PQCSettings::getDefaultForMetadataElementHeightDynamic() const {
        return true;
}

void PQCSettings::setDefaultForMetadataElementHeightDynamic() {
    if(true != m_metadataElementHeightDynamic) {
        m_metadataElementHeightDynamic = true;
        Q_EMIT metadataElementHeightDynamicChanged();
    }
}

QPointF PQCSettings::getMetadataElementPosition() const {
    return m_metadataElementPosition;
}

void PQCSettings::setMetadataElementPosition(const QPointF val) {
    if(val != m_metadataElementPosition) {
        m_metadataElementPosition = val;
        Q_EMIT metadataElementPositionChanged();
    }
}

const QPointF PQCSettings::getDefaultForMetadataElementPosition() const {
        return QPointF(100, 100);
}

void PQCSettings::setDefaultForMetadataElementPosition() {
    if(QPointF(100, 100) != m_metadataElementPosition) {
        m_metadataElementPosition = QPointF(100, 100);
        Q_EMIT metadataElementPositionChanged();
    }
}

QSizeF PQCSettings::getMetadataElementSize() const {
    return m_metadataElementSize;
}

void PQCSettings::setMetadataElementSize(const QSizeF val) {
    if(val != m_metadataElementSize) {
        m_metadataElementSize = val;
        Q_EMIT metadataElementSizeChanged();
    }
}

const QSizeF PQCSettings::getDefaultForMetadataElementSize() const {
        return QSize(400, 700);
}

void PQCSettings::setDefaultForMetadataElementSize() {
    if(QSize(400, 700) != m_metadataElementSize) {
        m_metadataElementSize = QSize(400, 700);
        Q_EMIT metadataElementSizeChanged();
    }
}

bool PQCSettings::getMetadataElementVisible() const {
    return m_metadataElementVisible;
}

void PQCSettings::setMetadataElementVisible(const bool val) {
    if(val != m_metadataElementVisible) {
        m_metadataElementVisible = val;
        Q_EMIT metadataElementVisibleChanged();
    }
}

const bool PQCSettings::getDefaultForMetadataElementVisible() const {
        return false;
}

void PQCSettings::setDefaultForMetadataElementVisible() {
    if(false != m_metadataElementVisible) {
        m_metadataElementVisible = false;
        Q_EMIT metadataElementVisibleChanged();
    }
}

bool PQCSettings::getMetadataExposureTime() const {
    return m_metadataExposureTime;
}

void PQCSettings::setMetadataExposureTime(const bool val) {
    if(val != m_metadataExposureTime) {
        m_metadataExposureTime = val;
        Q_EMIT metadataExposureTimeChanged();
    }
}

const bool PQCSettings::getDefaultForMetadataExposureTime() const {
        return true;
}

void PQCSettings::setDefaultForMetadataExposureTime() {
    if(true != m_metadataExposureTime) {
        m_metadataExposureTime = true;
        Q_EMIT metadataExposureTimeChanged();
    }
}

bool PQCSettings::getMetadataFLength() const {
    return m_metadataFLength;
}

void PQCSettings::setMetadataFLength(const bool val) {
    if(val != m_metadataFLength) {
        m_metadataFLength = val;
        Q_EMIT metadataFLengthChanged();
    }
}

const bool PQCSettings::getDefaultForMetadataFLength() const {
        return true;
}

void PQCSettings::setDefaultForMetadataFLength() {
    if(true != m_metadataFLength) {
        m_metadataFLength = true;
        Q_EMIT metadataFLengthChanged();
    }
}

bool PQCSettings::getMetadataFNumber() const {
    return m_metadataFNumber;
}

void PQCSettings::setMetadataFNumber(const bool val) {
    if(val != m_metadataFNumber) {
        m_metadataFNumber = val;
        Q_EMIT metadataFNumberChanged();
    }
}

const bool PQCSettings::getDefaultForMetadataFNumber() const {
        return true;
}

void PQCSettings::setDefaultForMetadataFNumber() {
    if(true != m_metadataFNumber) {
        m_metadataFNumber = true;
        Q_EMIT metadataFNumberChanged();
    }
}

bool PQCSettings::getMetadataFaceTagsBorder() const {
    return m_metadataFaceTagsBorder;
}

void PQCSettings::setMetadataFaceTagsBorder(const bool val) {
    if(val != m_metadataFaceTagsBorder) {
        m_metadataFaceTagsBorder = val;
        Q_EMIT metadataFaceTagsBorderChanged();
    }
}

const bool PQCSettings::getDefaultForMetadataFaceTagsBorder() const {
        return false;
}

void PQCSettings::setDefaultForMetadataFaceTagsBorder() {
    if(false != m_metadataFaceTagsBorder) {
        m_metadataFaceTagsBorder = false;
        Q_EMIT metadataFaceTagsBorderChanged();
    }
}

QString PQCSettings::getMetadataFaceTagsBorderColor() const {
    return m_metadataFaceTagsBorderColor;
}

void PQCSettings::setMetadataFaceTagsBorderColor(const QString val) {
    if(val != m_metadataFaceTagsBorderColor) {
        m_metadataFaceTagsBorderColor = val;
        Q_EMIT metadataFaceTagsBorderColorChanged();
    }
}

const QString PQCSettings::getDefaultForMetadataFaceTagsBorderColor() const {
        return "#44ff0000";
}

void PQCSettings::setDefaultForMetadataFaceTagsBorderColor() {
    if("#44ff0000" != m_metadataFaceTagsBorderColor) {
        m_metadataFaceTagsBorderColor = "#44ff0000";
        Q_EMIT metadataFaceTagsBorderColorChanged();
    }
}

int PQCSettings::getMetadataFaceTagsBorderWidth() const {
    return m_metadataFaceTagsBorderWidth;
}

void PQCSettings::setMetadataFaceTagsBorderWidth(const int val) {
    if(val != m_metadataFaceTagsBorderWidth) {
        m_metadataFaceTagsBorderWidth = val;
        Q_EMIT metadataFaceTagsBorderWidthChanged();
    }
}

const int PQCSettings::getDefaultForMetadataFaceTagsBorderWidth() const {
        return 3;
}

void PQCSettings::setDefaultForMetadataFaceTagsBorderWidth() {
    if(3 != m_metadataFaceTagsBorderWidth) {
        m_metadataFaceTagsBorderWidth = 3;
    }
}

bool PQCSettings::getMetadataFaceTagsEnabled() const {
    return m_metadataFaceTagsEnabled;
}

void PQCSettings::setMetadataFaceTagsEnabled(const bool val) {
    if(val != m_metadataFaceTagsEnabled) {
        m_metadataFaceTagsEnabled = val;
        Q_EMIT metadataFaceTagsEnabledChanged();
    }
}

const bool PQCSettings::getDefaultForMetadataFaceTagsEnabled() const {
        return true;
}

void PQCSettings::setDefaultForMetadataFaceTagsEnabled() {
    if(true != m_metadataFaceTagsEnabled) {
        m_metadataFaceTagsEnabled = true;
        Q_EMIT metadataFaceTagsEnabledChanged();
    }
}

int PQCSettings::getMetadataFaceTagsFontSize() const {
    return m_metadataFaceTagsFontSize;
}

void PQCSettings::setMetadataFaceTagsFontSize(const int val) {
    if(val != m_metadataFaceTagsFontSize) {
        m_metadataFaceTagsFontSize = val;
        Q_EMIT metadataFaceTagsFontSizeChanged();
    }
}

const int PQCSettings::getDefaultForMetadataFaceTagsFontSize() const {
        return 10;
}

void PQCSettings::setDefaultForMetadataFaceTagsFontSize() {
    if(10 != m_metadataFaceTagsFontSize) {
        m_metadataFaceTagsFontSize = 10;
    }
}

int PQCSettings::getMetadataFaceTagsVisibility() const {
    return m_metadataFaceTagsVisibility;
}

void PQCSettings::setMetadataFaceTagsVisibility(const int val) {
    if(val != m_metadataFaceTagsVisibility) {
        m_metadataFaceTagsVisibility = val;
        Q_EMIT metadataFaceTagsVisibilityChanged();
    }
}

const int PQCSettings::getDefaultForMetadataFaceTagsVisibility() const {
        return 1;
}

void PQCSettings::setDefaultForMetadataFaceTagsVisibility() {
    if(1 != m_metadataFaceTagsVisibility) {
        m_metadataFaceTagsVisibility = 1;
    }
}

bool PQCSettings::getMetadataFileSize() const {
    return m_metadataFileSize;
}

void PQCSettings::setMetadataFileSize(const bool val) {
    if(val != m_metadataFileSize) {
        m_metadataFileSize = val;
        Q_EMIT metadataFileSizeChanged();
    }
}

const bool PQCSettings::getDefaultForMetadataFileSize() const {
        return true;
}

void PQCSettings::setDefaultForMetadataFileSize() {
    if(true != m_metadataFileSize) {
        m_metadataFileSize = true;
        Q_EMIT metadataFileSizeChanged();
    }
}

bool PQCSettings::getMetadataFileType() const {
    return m_metadataFileType;
}

void PQCSettings::setMetadataFileType(const bool val) {
    if(val != m_metadataFileType) {
        m_metadataFileType = val;
        Q_EMIT metadataFileTypeChanged();
    }
}

const bool PQCSettings::getDefaultForMetadataFileType() const {
        return true;
}

void PQCSettings::setDefaultForMetadataFileType() {
    if(true != m_metadataFileType) {
        m_metadataFileType = true;
        Q_EMIT metadataFileTypeChanged();
    }
}

bool PQCSettings::getMetadataFilename() const {
    return m_metadataFilename;
}

void PQCSettings::setMetadataFilename(const bool val) {
    if(val != m_metadataFilename) {
        m_metadataFilename = val;
        Q_EMIT metadataFilenameChanged();
    }
}

const bool PQCSettings::getDefaultForMetadataFilename() const {
        return true;
}

void PQCSettings::setDefaultForMetadataFilename() {
    if(true != m_metadataFilename) {
        m_metadataFilename = true;
        Q_EMIT metadataFilenameChanged();
    }
}

bool PQCSettings::getMetadataFlash() const {
    return m_metadataFlash;
}

void PQCSettings::setMetadataFlash(const bool val) {
    if(val != m_metadataFlash) {
        m_metadataFlash = val;
        Q_EMIT metadataFlashChanged();
    }
}

const bool PQCSettings::getDefaultForMetadataFlash() const {
        return true;
}

void PQCSettings::setDefaultForMetadataFlash() {
    if(true != m_metadataFlash) {
        m_metadataFlash = true;
        Q_EMIT metadataFlashChanged();
    }
}

bool PQCSettings::getMetadataGps() const {
    return m_metadataGps;
}

void PQCSettings::setMetadataGps(const bool val) {
    if(val != m_metadataGps) {
        m_metadataGps = val;
        Q_EMIT metadataGpsChanged();
    }
}

const bool PQCSettings::getDefaultForMetadataGps() const {
        return true;
}

void PQCSettings::setDefaultForMetadataGps() {
    if(true != m_metadataGps) {
        m_metadataGps = true;
        Q_EMIT metadataGpsChanged();
    }
}

QString PQCSettings::getMetadataGpsMap() const {
    return m_metadataGpsMap;
}

void PQCSettings::setMetadataGpsMap(const QString val) {
    if(val != m_metadataGpsMap) {
        m_metadataGpsMap = val;
        Q_EMIT metadataGpsMapChanged();
    }
}

const QString PQCSettings::getDefaultForMetadataGpsMap() const {
        return "openstreetmap.org";
}

void PQCSettings::setDefaultForMetadataGpsMap() {
    if("openstreetmap.org" != m_metadataGpsMap) {
        m_metadataGpsMap = "openstreetmap.org";
        Q_EMIT metadataGpsMapChanged();
    }
}

bool PQCSettings::getMetadataImageNumber() const {
    return m_metadataImageNumber;
}

void PQCSettings::setMetadataImageNumber(const bool val) {
    if(val != m_metadataImageNumber) {
        m_metadataImageNumber = val;
        Q_EMIT metadataImageNumberChanged();
    }
}

const bool PQCSettings::getDefaultForMetadataImageNumber() const {
        return true;
}

void PQCSettings::setDefaultForMetadataImageNumber() {
    if(true != m_metadataImageNumber) {
        m_metadataImageNumber = true;
        Q_EMIT metadataImageNumberChanged();
    }
}

bool PQCSettings::getMetadataIso() const {
    return m_metadataIso;
}

void PQCSettings::setMetadataIso(const bool val) {
    if(val != m_metadataIso) {
        m_metadataIso = val;
        Q_EMIT metadataIsoChanged();
    }
}

const bool PQCSettings::getDefaultForMetadataIso() const {
        return true;
}

void PQCSettings::setDefaultForMetadataIso() {
    if(true != m_metadataIso) {
        m_metadataIso = true;
        Q_EMIT metadataIsoChanged();
    }
}

bool PQCSettings::getMetadataKeywords() const {
    return m_metadataKeywords;
}

void PQCSettings::setMetadataKeywords(const bool val) {
    if(val != m_metadataKeywords) {
        m_metadataKeywords = val;
        Q_EMIT metadataKeywordsChanged();
    }
}

const bool PQCSettings::getDefaultForMetadataKeywords() const {
        return false;
}

void PQCSettings::setDefaultForMetadataKeywords() {
    if(false != m_metadataKeywords) {
        m_metadataKeywords = false;
        Q_EMIT metadataKeywordsChanged();
    }
}

bool PQCSettings::getMetadataLightSource() const {
    return m_metadataLightSource;
}

void PQCSettings::setMetadataLightSource(const bool val) {
    if(val != m_metadataLightSource) {
        m_metadataLightSource = val;
        Q_EMIT metadataLightSourceChanged();
    }
}

const bool PQCSettings::getDefaultForMetadataLightSource() const {
        return false;
}

void PQCSettings::setDefaultForMetadataLightSource() {
    if(false != m_metadataLightSource) {
        m_metadataLightSource = false;
        Q_EMIT metadataLightSourceChanged();
    }
}

bool PQCSettings::getMetadataLocation() const {
    return m_metadataLocation;
}

void PQCSettings::setMetadataLocation(const bool val) {
    if(val != m_metadataLocation) {
        m_metadataLocation = val;
        Q_EMIT metadataLocationChanged();
    }
}

const bool PQCSettings::getDefaultForMetadataLocation() const {
        return false;
}

void PQCSettings::setDefaultForMetadataLocation() {
    if(false != m_metadataLocation) {
        m_metadataLocation = false;
        Q_EMIT metadataLocationChanged();
    }
}

bool PQCSettings::getMetadataMake() const {
    return m_metadataMake;
}

void PQCSettings::setMetadataMake(const bool val) {
    if(val != m_metadataMake) {
        m_metadataMake = val;
        Q_EMIT metadataMakeChanged();
    }
}

const bool PQCSettings::getDefaultForMetadataMake() const {
        return true;
}

void PQCSettings::setDefaultForMetadataMake() {
    if(true != m_metadataMake) {
        m_metadataMake = true;
        Q_EMIT metadataMakeChanged();
    }
}

bool PQCSettings::getMetadataModel() const {
    return m_metadataModel;
}

void PQCSettings::setMetadataModel(const bool val) {
    if(val != m_metadataModel) {
        m_metadataModel = val;
        Q_EMIT metadataModelChanged();
    }
}

const bool PQCSettings::getDefaultForMetadataModel() const {
        return true;
}

void PQCSettings::setDefaultForMetadataModel() {
    if(true != m_metadataModel) {
        m_metadataModel = true;
        Q_EMIT metadataModelChanged();
    }
}

bool PQCSettings::getMetadataSceneType() const {
    return m_metadataSceneType;
}

void PQCSettings::setMetadataSceneType(const bool val) {
    if(val != m_metadataSceneType) {
        m_metadataSceneType = val;
        Q_EMIT metadataSceneTypeChanged();
    }
}

const bool PQCSettings::getDefaultForMetadataSceneType() const {
        return true;
}

void PQCSettings::setDefaultForMetadataSceneType() {
    if(true != m_metadataSceneType) {
        m_metadataSceneType = true;
        Q_EMIT metadataSceneTypeChanged();
    }
}

bool PQCSettings::getMetadataSideBar() const {
    return m_metadataSideBar;
}

void PQCSettings::setMetadataSideBar(const bool val) {
    if(val != m_metadataSideBar) {
        m_metadataSideBar = val;
        Q_EMIT metadataSideBarChanged();
    }
}

const bool PQCSettings::getDefaultForMetadataSideBar() const {
        return true;
}

void PQCSettings::setDefaultForMetadataSideBar() {
    if(true != m_metadataSideBar) {
        m_metadataSideBar = true;
        Q_EMIT metadataSideBarChanged();
    }
}

QString PQCSettings::getMetadataSideBarLocation() const {
    return m_metadataSideBarLocation;
}

void PQCSettings::setMetadataSideBarLocation(const QString val) {
    if(val != m_metadataSideBarLocation) {
        m_metadataSideBarLocation = val;
        Q_EMIT metadataSideBarLocationChanged();
    }
}

const QString PQCSettings::getDefaultForMetadataSideBarLocation() const {
        return "right";
}

void PQCSettings::setDefaultForMetadataSideBarLocation() {
    if("right" != m_metadataSideBarLocation) {
        m_metadataSideBarLocation = "right";
        Q_EMIT metadataSideBarLocationChanged();
    }
}

int PQCSettings::getMetadataSideBarWidth() const {
    return m_metadataSideBarWidth;
}

void PQCSettings::setMetadataSideBarWidth(const int val) {
    if(val != m_metadataSideBarWidth) {
        m_metadataSideBarWidth = val;
        Q_EMIT metadataSideBarWidthChanged();
    }
}

const int PQCSettings::getDefaultForMetadataSideBarWidth() const {
        return 300;
}

void PQCSettings::setDefaultForMetadataSideBarWidth() {
    if(300 != m_metadataSideBarWidth) {
        m_metadataSideBarWidth = 300;
    }
}

bool PQCSettings::getMetadataSoftware() const {
    return m_metadataSoftware;
}

void PQCSettings::setMetadataSoftware(const bool val) {
    if(val != m_metadataSoftware) {
        m_metadataSoftware = val;
        Q_EMIT metadataSoftwareChanged();
    }
}

const bool PQCSettings::getDefaultForMetadataSoftware() const {
        return true;
}

void PQCSettings::setDefaultForMetadataSoftware() {
    if(true != m_metadataSoftware) {
        m_metadataSoftware = true;
        Q_EMIT metadataSoftwareChanged();
    }
}

bool PQCSettings::getMetadataTime() const {
    return m_metadataTime;
}

void PQCSettings::setMetadataTime(const bool val) {
    if(val != m_metadataTime) {
        m_metadataTime = val;
        Q_EMIT metadataTimeChanged();
    }
}

const bool PQCSettings::getDefaultForMetadataTime() const {
        return true;
}

void PQCSettings::setDefaultForMetadataTime() {
    if(true != m_metadataTime) {
        m_metadataTime = true;
        Q_EMIT metadataTimeChanged();
    }
}

bool PQCSettings::getSlideshowHideLabels() const {
    return m_slideshowHideLabels;
}

void PQCSettings::setSlideshowHideLabels(const bool val) {
    if(val != m_slideshowHideLabels) {
        m_slideshowHideLabels = val;
        Q_EMIT slideshowHideLabelsChanged();
    }
}

const bool PQCSettings::getDefaultForSlideshowHideLabels() const {
        return true;
}

void PQCSettings::setDefaultForSlideshowHideLabels() {
    if(true != m_slideshowHideLabels) {
        m_slideshowHideLabels = true;
        Q_EMIT slideshowHideLabelsChanged();
    }
}

bool PQCSettings::getSlideshowHideWindowButtons() const {
    return m_slideshowHideWindowButtons;
}

void PQCSettings::setSlideshowHideWindowButtons(const bool val) {
    if(val != m_slideshowHideWindowButtons) {
        m_slideshowHideWindowButtons = val;
        Q_EMIT slideshowHideWindowButtonsChanged();
    }
}

const bool PQCSettings::getDefaultForSlideshowHideWindowButtons() const {
        return false;
}

void PQCSettings::setDefaultForSlideshowHideWindowButtons() {
    if(false != m_slideshowHideWindowButtons) {
        m_slideshowHideWindowButtons = false;
        Q_EMIT slideshowHideWindowButtonsChanged();
    }
}

int PQCSettings::getSlideshowImageTransition() const {
    return m_slideshowImageTransition;
}

void PQCSettings::setSlideshowImageTransition(const int val) {
    if(val != m_slideshowImageTransition) {
        m_slideshowImageTransition = val;
        Q_EMIT slideshowImageTransitionChanged();
    }
}

const int PQCSettings::getDefaultForSlideshowImageTransition() const {
        return 4;
}

void PQCSettings::setDefaultForSlideshowImageTransition() {
    if(4 != m_slideshowImageTransition) {
        m_slideshowImageTransition = 4;
    }
}

bool PQCSettings::getSlideshowIncludeSubFolders() const {
    return m_slideshowIncludeSubFolders;
}

void PQCSettings::setSlideshowIncludeSubFolders(const bool val) {
    if(val != m_slideshowIncludeSubFolders) {
        m_slideshowIncludeSubFolders = val;
        Q_EMIT slideshowIncludeSubFoldersChanged();
    }
}

const bool PQCSettings::getDefaultForSlideshowIncludeSubFolders() const {
        return false;
}

void PQCSettings::setDefaultForSlideshowIncludeSubFolders() {
    if(false != m_slideshowIncludeSubFolders) {
        m_slideshowIncludeSubFolders = false;
        Q_EMIT slideshowIncludeSubFoldersChanged();
    }
}

bool PQCSettings::getSlideshowLoop() const {
    return m_slideshowLoop;
}

void PQCSettings::setSlideshowLoop(const bool val) {
    if(val != m_slideshowLoop) {
        m_slideshowLoop = val;
        Q_EMIT slideshowLoopChanged();
    }
}

const bool PQCSettings::getDefaultForSlideshowLoop() const {
        return true;
}

void PQCSettings::setDefaultForSlideshowLoop() {
    if(true != m_slideshowLoop) {
        m_slideshowLoop = true;
        Q_EMIT slideshowLoopChanged();
    }
}

bool PQCSettings::getSlideshowMusic() const {
    return m_slideshowMusic;
}

void PQCSettings::setSlideshowMusic(const bool val) {
    if(val != m_slideshowMusic) {
        m_slideshowMusic = val;
        Q_EMIT slideshowMusicChanged();
    }
}

const bool PQCSettings::getDefaultForSlideshowMusic() const {
        return false;
}

void PQCSettings::setDefaultForSlideshowMusic() {
    if(false != m_slideshowMusic) {
        m_slideshowMusic = false;
        Q_EMIT slideshowMusicChanged();
    }
}

QString PQCSettings::getSlideshowMusicFile() const {
    return m_slideshowMusicFile;
}

void PQCSettings::setSlideshowMusicFile(const QString val) {
    if(val != m_slideshowMusicFile) {
        m_slideshowMusicFile = val;
        Q_EMIT slideshowMusicFileChanged();
    }
}

const QString PQCSettings::getDefaultForSlideshowMusicFile() const {
        return "";
}

void PQCSettings::setDefaultForSlideshowMusicFile() {
    if("" != m_slideshowMusicFile) {
        m_slideshowMusicFile = "";
        Q_EMIT slideshowMusicFileChanged();
    }
}

QStringList PQCSettings::getSlideshowMusicFiles() const {
    return m_slideshowMusicFiles;
}

void PQCSettings::setSlideshowMusicFiles(const QStringList val) {
    if(val != m_slideshowMusicFiles) {
        m_slideshowMusicFiles = val;
        Q_EMIT slideshowMusicFilesChanged();
    }
}

const QStringList PQCSettings::getDefaultForSlideshowMusicFiles() const {
        return QStringList() << "";
}

void PQCSettings::setDefaultForSlideshowMusicFiles() {
    QStringList tmp = QStringList() << "";
    if(tmp != m_slideshowMusicFiles) {
        m_slideshowMusicFiles = tmp;
        Q_EMIT slideshowMusicFilesChanged();
    }
}

bool PQCSettings::getSlideshowMusicShuffle() const {
    return m_slideshowMusicShuffle;
}

void PQCSettings::setSlideshowMusicShuffle(const bool val) {
    if(val != m_slideshowMusicShuffle) {
        m_slideshowMusicShuffle = val;
        Q_EMIT slideshowMusicShuffleChanged();
    }
}

const bool PQCSettings::getDefaultForSlideshowMusicShuffle() const {
        return false;
}

void PQCSettings::setDefaultForSlideshowMusicShuffle() {
    if(false != m_slideshowMusicShuffle) {
        m_slideshowMusicShuffle = false;
        Q_EMIT slideshowMusicShuffleChanged();
    }
}

int PQCSettings::getSlideshowMusicVolumeVideos() const {
    return m_slideshowMusicVolumeVideos;
}

void PQCSettings::setSlideshowMusicVolumeVideos(const int val) {
    if(val != m_slideshowMusicVolumeVideos) {
        m_slideshowMusicVolumeVideos = val;
        Q_EMIT slideshowMusicVolumeVideosChanged();
    }
}

const int PQCSettings::getDefaultForSlideshowMusicVolumeVideos() const {
        return 1;
}

void PQCSettings::setDefaultForSlideshowMusicVolumeVideos() {
    if(1 != m_slideshowMusicVolumeVideos) {
        m_slideshowMusicVolumeVideos = 1;
    }
}

bool PQCSettings::getSlideshowShuffle() const {
    return m_slideshowShuffle;
}

void PQCSettings::setSlideshowShuffle(const bool val) {
    if(val != m_slideshowShuffle) {
        m_slideshowShuffle = val;
        Q_EMIT slideshowShuffleChanged();
    }
}

const bool PQCSettings::getDefaultForSlideshowShuffle() const {
        return false;
}

void PQCSettings::setDefaultForSlideshowShuffle() {
    if(false != m_slideshowShuffle) {
        m_slideshowShuffle = false;
        Q_EMIT slideshowShuffleChanged();
    }
}

int PQCSettings::getSlideshowTime() const {
    return m_slideshowTime;
}

void PQCSettings::setSlideshowTime(const int val) {
    if(val != m_slideshowTime) {
        m_slideshowTime = val;
        Q_EMIT slideshowTimeChanged();
    }
}

const int PQCSettings::getDefaultForSlideshowTime() const {
        return 5;
}

void PQCSettings::setDefaultForSlideshowTime() {
    if(5 != m_slideshowTime) {
        m_slideshowTime = 5;
    }
}

QString PQCSettings::getSlideshowTypeAnimation() const {
    return m_slideshowTypeAnimation;
}

void PQCSettings::setSlideshowTypeAnimation(const QString val) {
    if(val != m_slideshowTypeAnimation) {
        m_slideshowTypeAnimation = val;
        Q_EMIT slideshowTypeAnimationChanged();
    }
}

const QString PQCSettings::getDefaultForSlideshowTypeAnimation() const {
        return "opacity";
}

void PQCSettings::setDefaultForSlideshowTypeAnimation() {
    if("opacity" != m_slideshowTypeAnimation) {
        m_slideshowTypeAnimation = "opacity";
        Q_EMIT slideshowTypeAnimationChanged();
    }
}

bool PQCSettings::getThumbnailsCache() const {
    return m_thumbnailsCache;
}

void PQCSettings::setThumbnailsCache(const bool val) {
    if(val != m_thumbnailsCache) {
        m_thumbnailsCache = val;
        Q_EMIT thumbnailsCacheChanged();
    }
}

const bool PQCSettings::getDefaultForThumbnailsCache() const {
        return true;
}

void PQCSettings::setDefaultForThumbnailsCache() {
    if(true != m_thumbnailsCache) {
        m_thumbnailsCache = true;
        Q_EMIT thumbnailsCacheChanged();
    }
}

bool PQCSettings::getThumbnailsCacheBaseDirDefault() const {
    return m_thumbnailsCacheBaseDirDefault;
}

void PQCSettings::setThumbnailsCacheBaseDirDefault(const bool val) {
    if(val != m_thumbnailsCacheBaseDirDefault) {
        m_thumbnailsCacheBaseDirDefault = val;
        Q_EMIT thumbnailsCacheBaseDirDefaultChanged();
    }
}

const bool PQCSettings::getDefaultForThumbnailsCacheBaseDirDefault() const {
        return true;
}

void PQCSettings::setDefaultForThumbnailsCacheBaseDirDefault() {
    if(true != m_thumbnailsCacheBaseDirDefault) {
        m_thumbnailsCacheBaseDirDefault = true;
        Q_EMIT thumbnailsCacheBaseDirDefaultChanged();
    }
}

QString PQCSettings::getThumbnailsCacheBaseDirLocation() const {
    return m_thumbnailsCacheBaseDirLocation;
}

void PQCSettings::setThumbnailsCacheBaseDirLocation(const QString val) {
    if(val != m_thumbnailsCacheBaseDirLocation) {
        m_thumbnailsCacheBaseDirLocation = val;
        Q_EMIT thumbnailsCacheBaseDirLocationChanged();
    }
}

const QString PQCSettings::getDefaultForThumbnailsCacheBaseDirLocation() const {
        return "";
}

void PQCSettings::setDefaultForThumbnailsCacheBaseDirLocation() {
    if("" != m_thumbnailsCacheBaseDirLocation) {
        m_thumbnailsCacheBaseDirLocation = "";
        Q_EMIT thumbnailsCacheBaseDirLocationChanged();
    }
}

bool PQCSettings::getThumbnailsCenterOnActive() const {
    return m_thumbnailsCenterOnActive;
}

void PQCSettings::setThumbnailsCenterOnActive(const bool val) {
    if(val != m_thumbnailsCenterOnActive) {
        m_thumbnailsCenterOnActive = val;
        Q_EMIT thumbnailsCenterOnActiveChanged();
    }
}

const bool PQCSettings::getDefaultForThumbnailsCenterOnActive() const {
        return false;
}

void PQCSettings::setDefaultForThumbnailsCenterOnActive() {
    if(false != m_thumbnailsCenterOnActive) {
        m_thumbnailsCenterOnActive = false;
        Q_EMIT thumbnailsCenterOnActiveChanged();
    }
}

bool PQCSettings::getThumbnailsCropToFit() const {
    return m_thumbnailsCropToFit;
}

void PQCSettings::setThumbnailsCropToFit(const bool val) {
    if(val != m_thumbnailsCropToFit) {
        m_thumbnailsCropToFit = val;
        Q_EMIT thumbnailsCropToFitChanged();
    }
}

const bool PQCSettings::getDefaultForThumbnailsCropToFit() const {
        return true;
}

void PQCSettings::setDefaultForThumbnailsCropToFit() {
    if(true != m_thumbnailsCropToFit) {
        m_thumbnailsCropToFit = true;
        Q_EMIT thumbnailsCropToFitChanged();
    }
}

bool PQCSettings::getThumbnailsDisable() const {
    return m_thumbnailsDisable;
}

void PQCSettings::setThumbnailsDisable(const bool val) {
    if(val != m_thumbnailsDisable) {
        m_thumbnailsDisable = val;
        Q_EMIT thumbnailsDisableChanged();
    }
}

const bool PQCSettings::getDefaultForThumbnailsDisable() const {
        return false;
}

void PQCSettings::setDefaultForThumbnailsDisable() {
    if(false != m_thumbnailsDisable) {
        m_thumbnailsDisable = false;
        Q_EMIT thumbnailsDisableChanged();
    }
}

QString PQCSettings::getThumbnailsExcludeDropBox() const {
    return m_thumbnailsExcludeDropBox;
}

void PQCSettings::setThumbnailsExcludeDropBox(const QString val) {
    if(val != m_thumbnailsExcludeDropBox) {
        m_thumbnailsExcludeDropBox = val;
        Q_EMIT thumbnailsExcludeDropBoxChanged();
    }
}

const QString PQCSettings::getDefaultForThumbnailsExcludeDropBox() const {
        return "";
}

void PQCSettings::setDefaultForThumbnailsExcludeDropBox() {
    if("" != m_thumbnailsExcludeDropBox) {
        m_thumbnailsExcludeDropBox = "";
        Q_EMIT thumbnailsExcludeDropBoxChanged();
    }
}

QStringList PQCSettings::getThumbnailsExcludeFolders() const {
    return m_thumbnailsExcludeFolders;
}

void PQCSettings::setThumbnailsExcludeFolders(const QStringList val) {
    if(val != m_thumbnailsExcludeFolders) {
        m_thumbnailsExcludeFolders = val;
        Q_EMIT thumbnailsExcludeFoldersChanged();
    }
}

const QStringList PQCSettings::getDefaultForThumbnailsExcludeFolders() const {
        return QStringList() << "";
}

void PQCSettings::setDefaultForThumbnailsExcludeFolders() {
    QStringList tmp = QStringList() << "";
    if(tmp != m_thumbnailsExcludeFolders) {
        m_thumbnailsExcludeFolders = tmp;
        Q_EMIT thumbnailsExcludeFoldersChanged();
    }
}

bool PQCSettings::getThumbnailsExcludeNetworkShares() const {
    return m_thumbnailsExcludeNetworkShares;
}

void PQCSettings::setThumbnailsExcludeNetworkShares(const bool val) {
    if(val != m_thumbnailsExcludeNetworkShares) {
        m_thumbnailsExcludeNetworkShares = val;
        Q_EMIT thumbnailsExcludeNetworkSharesChanged();
    }
}

const bool PQCSettings::getDefaultForThumbnailsExcludeNetworkShares() const {
        return true;
}

void PQCSettings::setDefaultForThumbnailsExcludeNetworkShares() {
    if(true != m_thumbnailsExcludeNetworkShares) {
        m_thumbnailsExcludeNetworkShares = true;
        Q_EMIT thumbnailsExcludeNetworkSharesChanged();
    }
}

QString PQCSettings::getThumbnailsExcludeNextcloud() const {
    return m_thumbnailsExcludeNextcloud;
}

void PQCSettings::setThumbnailsExcludeNextcloud(const QString val) {
    if(val != m_thumbnailsExcludeNextcloud) {
        m_thumbnailsExcludeNextcloud = val;
        Q_EMIT thumbnailsExcludeNextcloudChanged();
    }
}

const QString PQCSettings::getDefaultForThumbnailsExcludeNextcloud() const {
        return "";
}

void PQCSettings::setDefaultForThumbnailsExcludeNextcloud() {
    if("" != m_thumbnailsExcludeNextcloud) {
        m_thumbnailsExcludeNextcloud = "";
        Q_EMIT thumbnailsExcludeNextcloudChanged();
    }
}

QString PQCSettings::getThumbnailsExcludeOwnCloud() const {
    return m_thumbnailsExcludeOwnCloud;
}

void PQCSettings::setThumbnailsExcludeOwnCloud(const QString val) {
    if(val != m_thumbnailsExcludeOwnCloud) {
        m_thumbnailsExcludeOwnCloud = val;
        Q_EMIT thumbnailsExcludeOwnCloudChanged();
    }
}

const QString PQCSettings::getDefaultForThumbnailsExcludeOwnCloud() const {
        return "";
}

void PQCSettings::setDefaultForThumbnailsExcludeOwnCloud() {
    if("" != m_thumbnailsExcludeOwnCloud) {
        m_thumbnailsExcludeOwnCloud = "";
        Q_EMIT thumbnailsExcludeOwnCloudChanged();
    }
}

bool PQCSettings::getThumbnailsFilename() const {
    return m_thumbnailsFilename;
}

void PQCSettings::setThumbnailsFilename(const bool val) {
    if(val != m_thumbnailsFilename) {
        m_thumbnailsFilename = val;
        Q_EMIT thumbnailsFilenameChanged();
    }
}

const bool PQCSettings::getDefaultForThumbnailsFilename() const {
        return true;
}

void PQCSettings::setDefaultForThumbnailsFilename() {
    if(true != m_thumbnailsFilename) {
        m_thumbnailsFilename = true;
        Q_EMIT thumbnailsFilenameChanged();
    }
}

int PQCSettings::getThumbnailsFontSize() const {
    return m_thumbnailsFontSize;
}

void PQCSettings::setThumbnailsFontSize(const int val) {
    if(val != m_thumbnailsFontSize) {
        m_thumbnailsFontSize = val;
        Q_EMIT thumbnailsFontSizeChanged();
    }
}

const int PQCSettings::getDefaultForThumbnailsFontSize() const {
        return 7;
}

void PQCSettings::setDefaultForThumbnailsFontSize() {
    if(7 != m_thumbnailsFontSize) {
        m_thumbnailsFontSize = 7;
    }
}

QStringList PQCSettings::getThumbnailsHighlightAnimation() const {
    return m_thumbnailsHighlightAnimation;
}

void PQCSettings::setThumbnailsHighlightAnimation(const QStringList val) {
    if(val != m_thumbnailsHighlightAnimation) {
        m_thumbnailsHighlightAnimation = val;
        Q_EMIT thumbnailsHighlightAnimationChanged();
    }
}

const QStringList PQCSettings::getDefaultForThumbnailsHighlightAnimation() const {
        return QStringList() << "liftup";
}

void PQCSettings::setDefaultForThumbnailsHighlightAnimation() {
    QStringList tmp = QStringList() << "liftup";
    if(tmp != m_thumbnailsHighlightAnimation) {
        m_thumbnailsHighlightAnimation = tmp;
        Q_EMIT thumbnailsHighlightAnimationChanged();
    }
}

int PQCSettings::getThumbnailsHighlightAnimationLiftUp() const {
    return m_thumbnailsHighlightAnimationLiftUp;
}

void PQCSettings::setThumbnailsHighlightAnimationLiftUp(const int val) {
    if(val != m_thumbnailsHighlightAnimationLiftUp) {
        m_thumbnailsHighlightAnimationLiftUp = val;
        Q_EMIT thumbnailsHighlightAnimationLiftUpChanged();
    }
}

const int PQCSettings::getDefaultForThumbnailsHighlightAnimationLiftUp() const {
        return 15;
}

void PQCSettings::setDefaultForThumbnailsHighlightAnimationLiftUp() {
    if(15 != m_thumbnailsHighlightAnimationLiftUp) {
        m_thumbnailsHighlightAnimationLiftUp = 15;
    }
}

bool PQCSettings::getThumbnailsIconsOnly() const {
    return m_thumbnailsIconsOnly;
}

void PQCSettings::setThumbnailsIconsOnly(const bool val) {
    if(val != m_thumbnailsIconsOnly) {
        m_thumbnailsIconsOnly = val;
        Q_EMIT thumbnailsIconsOnlyChanged();
    }
}

const bool PQCSettings::getDefaultForThumbnailsIconsOnly() const {
        return false;
}

void PQCSettings::setDefaultForThumbnailsIconsOnly() {
    if(false != m_thumbnailsIconsOnly) {
        m_thumbnailsIconsOnly = false;
        Q_EMIT thumbnailsIconsOnlyChanged();
    }
}

bool PQCSettings::getThumbnailsInactiveTransparent() const {
    return m_thumbnailsInactiveTransparent;
}

void PQCSettings::setThumbnailsInactiveTransparent(const bool val) {
    if(val != m_thumbnailsInactiveTransparent) {
        m_thumbnailsInactiveTransparent = val;
        Q_EMIT thumbnailsInactiveTransparentChanged();
    }
}

const bool PQCSettings::getDefaultForThumbnailsInactiveTransparent() const {
        return true;
}

void PQCSettings::setDefaultForThumbnailsInactiveTransparent() {
    if(true != m_thumbnailsInactiveTransparent) {
        m_thumbnailsInactiveTransparent = true;
        Q_EMIT thumbnailsInactiveTransparentChanged();
    }
}

int PQCSettings::getThumbnailsMaxNumberThreads() const {
    return m_thumbnailsMaxNumberThreads;
}

void PQCSettings::setThumbnailsMaxNumberThreads(const int val) {
    if(val != m_thumbnailsMaxNumberThreads) {
        m_thumbnailsMaxNumberThreads = val;
        Q_EMIT thumbnailsMaxNumberThreadsChanged();
    }
}

const int PQCSettings::getDefaultForThumbnailsMaxNumberThreads() const {
        return 4;
}

void PQCSettings::setDefaultForThumbnailsMaxNumberThreads() {
    if(4 != m_thumbnailsMaxNumberThreads) {
        m_thumbnailsMaxNumberThreads = 4;
    }
}

bool PQCSettings::getThumbnailsSameHeightVaryWidth() const {
    return m_thumbnailsSameHeightVaryWidth;
}

void PQCSettings::setThumbnailsSameHeightVaryWidth(const bool val) {
    if(val != m_thumbnailsSameHeightVaryWidth) {
        m_thumbnailsSameHeightVaryWidth = val;
        Q_EMIT thumbnailsSameHeightVaryWidthChanged();
    }
}

const bool PQCSettings::getDefaultForThumbnailsSameHeightVaryWidth() const {
        return false;
}

void PQCSettings::setDefaultForThumbnailsSameHeightVaryWidth() {
    if(false != m_thumbnailsSameHeightVaryWidth) {
        m_thumbnailsSameHeightVaryWidth = false;
        Q_EMIT thumbnailsSameHeightVaryWidthChanged();
    }
}

int PQCSettings::getThumbnailsSize() const {
    return m_thumbnailsSize;
}

void PQCSettings::setThumbnailsSize(const int val) {
    if(val != m_thumbnailsSize) {
        m_thumbnailsSize = val;
        Q_EMIT thumbnailsSizeChanged();
    }
}

const int PQCSettings::getDefaultForThumbnailsSize() const {
        return 14;
}

void PQCSettings::setDefaultForThumbnailsSize() {
    if(14 != m_thumbnailsSize) {
        m_thumbnailsSize = 14;
    }
}

bool PQCSettings::getThumbnailsSmallThumbnailsKeepSmall() const {
    return m_thumbnailsSmallThumbnailsKeepSmall;
}

void PQCSettings::setThumbnailsSmallThumbnailsKeepSmall(const bool val) {
    if(val != m_thumbnailsSmallThumbnailsKeepSmall) {
        m_thumbnailsSmallThumbnailsKeepSmall = val;
        Q_EMIT thumbnailsSmallThumbnailsKeepSmallChanged();
    }
}

const bool PQCSettings::getDefaultForThumbnailsSmallThumbnailsKeepSmall() const {
        return true;
}

void PQCSettings::setDefaultForThumbnailsSmallThumbnailsKeepSmall() {
    if(true != m_thumbnailsSmallThumbnailsKeepSmall) {
        m_thumbnailsSmallThumbnailsKeepSmall = true;
        Q_EMIT thumbnailsSmallThumbnailsKeepSmallChanged();
    }
}

int PQCSettings::getThumbnailsSpacing() const {
    return m_thumbnailsSpacing;
}

void PQCSettings::setThumbnailsSpacing(const int val) {
    if(val != m_thumbnailsSpacing) {
        m_thumbnailsSpacing = val;
        Q_EMIT thumbnailsSpacingChanged();
    }
}

const int PQCSettings::getDefaultForThumbnailsSpacing() const {
        return 2;
}

void PQCSettings::setDefaultForThumbnailsSpacing() {
    if(2 != m_thumbnailsSpacing) {
        m_thumbnailsSpacing = 2;
    }
}

bool PQCSettings::getThumbnailsTooltip() const {
    return m_thumbnailsTooltip;
}

void PQCSettings::setThumbnailsTooltip(const bool val) {
    if(val != m_thumbnailsTooltip) {
        m_thumbnailsTooltip = val;
        Q_EMIT thumbnailsTooltipChanged();
    }
}

const bool PQCSettings::getDefaultForThumbnailsTooltip() const {
        return true;
}

void PQCSettings::setDefaultForThumbnailsTooltip() {
    if(true != m_thumbnailsTooltip) {
        m_thumbnailsTooltip = true;
        Q_EMIT thumbnailsTooltipChanged();
    }
}

int PQCSettings::getThumbnailsVisibility() const {
    return m_thumbnailsVisibility;
}

void PQCSettings::setThumbnailsVisibility(const int val) {
    if(val != m_thumbnailsVisibility) {
        m_thumbnailsVisibility = val;
        Q_EMIT thumbnailsVisibilityChanged();
    }
}

const int PQCSettings::getDefaultForThumbnailsVisibility() const {
        return 0;
}

void PQCSettings::setDefaultForThumbnailsVisibility() {
    if(0 != m_thumbnailsVisibility) {
        m_thumbnailsVisibility = 0;
    }
}

void PQCSettings::readDB() {

    qDebug() << "";

    QSqlDatabase db = QSqlDatabase::database("settings");

    if(!db.isOpen()) return;

    for(const auto &table : std::as_const(dbtables)) {

        QSqlQuery query(db);
        query.prepare(QString("SELECT `name`,`value` FROM '%1'").arg(table));
        if(!query.exec())
            qCritical() << QString("SQL Query error (%1):").arg(table) << query.lastError().text();

        while(query.next()) {

            QString name = query.value(0).toString();
            QVariant value = query.value(1).toString();
        
            // table: filedialog
            if(table == "filedialog") {
                if(name == "DetailsTooltip") {
                    m_filedialogDetailsTooltip = value.toInt();
                } else if(name == "Devices") {
                    m_filedialogDevices = value.toInt();
                } else if(name == "DevicesShowTmpfs") {
                    m_filedialogDevicesShowTmpfs = value.toInt();
                } else if(name == "DragDropFileviewGrid") {
                    m_filedialogDragDropFileviewGrid = value.toInt();
                } else if(name == "DragDropFileviewList") {
                    m_filedialogDragDropFileviewList = value.toInt();
                } else if(name == "DragDropFileviewMasonry") {
                    m_filedialogDragDropFileviewMasonry = value.toInt();
                } else if(name == "DragDropPlaces") {
                    m_filedialogDragDropPlaces = value.toInt();
                } else if(name == "ElementPadding") {
                    m_filedialogElementPadding = value.toInt();
                } else if(name == "FolderContentThumbnails") {
                    m_filedialogFolderContentThumbnails = value.toInt();
                } else if(name == "FolderContentThumbnailsAutoload") {
                    m_filedialogFolderContentThumbnailsAutoload = value.toInt();
                } else if(name == "FolderContentThumbnailsLoop") {
                    m_filedialogFolderContentThumbnailsLoop = value.toInt();
                } else if(name == "FolderContentThumbnailsScaleCrop") {
                    m_filedialogFolderContentThumbnailsScaleCrop = value.toInt();
                } else if(name == "FolderContentThumbnailsSortAscending") {
                    m_filedialogFolderContentThumbnailsSortAscending = value.toInt();
                } else if(name == "FolderContentThumbnailsSortBy") {
                    m_filedialogFolderContentThumbnailsSortBy = value.toString();
                } else if(name == "FolderContentThumbnailsSpeed") {
                    m_filedialogFolderContentThumbnailsSpeed = value.toInt();
                } else if(name == "LabelsShowGrid") {
                    m_filedialogLabelsShowGrid = value.toInt();
                } else if(name == "LabelsShowMasonry") {
                    m_filedialogLabelsShowMasonry = value.toInt();
                } else if(name == "Layout") {
                    m_filedialogLayout = value.toString();
                } else if(name == "Places") {
                    m_filedialogPlaces = value.toInt();
                } else if(name == "PlacesWidth") {
                    m_filedialogPlacesWidth = value.toInt();
                } else if(name == "Preview") {
                    m_filedialogPreview = value.toInt();
                } else if(name == "PreviewBlur") {
                    m_filedialogPreviewBlur = value.toInt();
                } else if(name == "PreviewColorIntensity") {
                    m_filedialogPreviewColorIntensity = value.toInt();
                } else if(name == "PreviewCropToFit") {
                    m_filedialogPreviewCropToFit = value.toInt();
                } else if(name == "PreviewHigherResolution") {
                    m_filedialogPreviewHigherResolution = value.toInt();
                } else if(name == "PreviewMuted") {
                    m_filedialogPreviewMuted = value.toInt();
                } else if(name == "RememberSelection") {
                    m_filedialogRememberSelection = value.toInt();
                } else if(name == "ShowHiddenFilesFolders") {
                    m_filedialogShowHiddenFilesFolders = value.toInt();
                } else if(name == "SingleClickSelect") {
                    m_filedialogSingleClickSelect = value.toInt();
                } else if(name == "StartupRestoreCustom") {
                    m_filedialogStartupRestoreCustom = value.toInt();
                } else if(name == "StartupRestoreCustomFolder") {
                    m_filedialogStartupRestoreCustomFolder = value.toString();
                } else if(name == "StartupRestoreHome") {
                    m_filedialogStartupRestoreHome = value.toInt();
                } else if(name == "StartupRestorePrevious") {
                    m_filedialogStartupRestorePrevious = value.toInt();
                } else if(name == "ThumbnailSizeFollowsGlobalThumbnails") {
                    m_filedialogThumbnailSizeFollowsGlobalThumbnails = value.toInt();
                } else if(name == "Thumbnails") {
                    m_filedialogThumbnails = value.toInt();
                } else if(name == "ThumbnailsScaleCrop") {
                    m_filedialogThumbnailsScaleCrop = value.toInt();
                } else if(name == "UseNativeFileDialog") {
                    m_filedialogUseNativeFileDialog = value.toInt();
                } else if(name == "Zoom") {
                    m_filedialogZoom = value.toInt();
                }
            // table: filetypes
            } else if(table == "filetypes") {
                if(name == "AnimatedControls") {
                    m_filetypesAnimatedControls = value.toInt();
                } else if(name == "AnimatedLeftRight") {
                    m_filetypesAnimatedLeftRight = value.toInt();
                } else if(name == "AnimatedSpacePause") {
                    m_filetypesAnimatedSpacePause = value.toInt();
                } else if(name == "ArchiveAlwaysEnterAutomatically") {
                    m_filetypesArchiveAlwaysEnterAutomatically = value.toInt();
                } else if(name == "ArchiveControls") {
                    m_filetypesArchiveControls = value.toInt();
                } else if(name == "ArchiveDontLoadMoreFilesThan") {
                    m_filetypesArchiveDontLoadMoreFilesThan = value.toInt();
                } else if(name == "ArchiveDontLoadMoreFilesThanCount") {
                    m_filetypesArchiveDontLoadMoreFilesThanCount = value.toInt();
                } else if(name == "ArchiveIgnoreLargerThan") {
                    m_filetypesArchiveIgnoreLargerThan = value.toInt();
                } else if(name == "ArchiveIgnoreLargerThanSize") {
                    m_filetypesArchiveIgnoreLargerThanSize = value.toInt();
                } else if(name == "ArchiveLeftRight") {
                    m_filetypesArchiveLeftRight = value.toInt();
                } else if(name == "ArchiveViewerModeExitButton") {
                    m_filetypesArchiveViewerModeExitButton = value.toInt();
                } else if(name == "ComicBookAlwaysEnterAutomatically") {
                    m_filetypesComicBookAlwaysEnterAutomatically = value.toInt();
                } else if(name == "DocumentAlwaysEnterAutomatically") {
                    m_filetypesDocumentAlwaysEnterAutomatically = value.toInt();
                } else if(name == "DocumentControls") {
                    m_filetypesDocumentControls = value.toInt();
                } else if(name == "DocumentLeftRight") {
                    m_filetypesDocumentLeftRight = value.toInt();
                } else if(name == "DocumentViewerModeExitButton") {
                    m_filetypesDocumentViewerModeExitButton = value.toInt();
                } else if(name == "ExternalUnrar") {
                    m_filetypesExternalUnrar = value.toInt();
                } else if(name == "LoadAppleLivePhotos") {
                    m_filetypesLoadAppleLivePhotos = value.toInt();
                } else if(name == "LoadMotionPhotos") {
                    m_filetypesLoadMotionPhotos = value.toInt();
                } else if(name == "MotionAutoPlay") {
                    m_filetypesMotionAutoPlay = value.toInt();
                } else if(name == "MotionPhotoPlayPause") {
                    m_filetypesMotionPhotoPlayPause = value.toInt();
                } else if(name == "MotionSpacePause") {
                    m_filetypesMotionSpacePause = value.toInt();
                } else if(name == "PDFQuality") {
                    m_filetypesPDFQuality = value.toInt();
                } else if(name == "PhotoSphereArrowKeys") {
                    m_filetypesPhotoSphereArrowKeys = value.toInt();
                } else if(name == "PhotoSphereAutoLoad") {
                    m_filetypesPhotoSphereAutoLoad = value.toInt();
                } else if(name == "PhotoSphereBigButton") {
                    m_filetypesPhotoSphereBigButton = value.toInt();
                } else if(name == "PhotoSphereControls") {
                    m_filetypesPhotoSphereControls = value.toInt();
                } else if(name == "PhotoSpherePanOnLoad") {
                    m_filetypesPhotoSpherePanOnLoad = value.toInt();
                } else if(name == "RAWUseEmbeddedIfAvailable") {
                    m_filetypesRAWUseEmbeddedIfAvailable = value.toInt();
                } else if(name == "VideoAutoplay") {
                    m_filetypesVideoAutoplay = value.toInt();
                } else if(name == "VideoBackend") {
                    QString val = value.toString();
                    if(val.contains(":://::"))
                        m_filetypesVideoBackend = val.split(":://::");
                    else if(!val.isEmpty())
                        m_filetypesVideoBackend = QStringList() << val;
                    else
                        m_filetypesVideoBackend = QStringList();
                } else if(name == "VideoLeftRightJumpVideo") {
                    m_filetypesVideoLeftRightJumpVideo = value.toInt();
                } else if(name == "VideoLoop") {
                    m_filetypesVideoLoop = value.toInt();
                } else if(name == "VideoSpacePause") {
                    m_filetypesVideoSpacePause = value.toInt();
                } else if(name == "VideoThumbnailer") {
                    m_filetypesVideoThumbnailer = value.toString();
                } else if(name == "VideoVolume") {
                    m_filetypesVideoVolume = value.toInt();
                }
            // table: general
            } else if(table == "general") {
                if(name == "AutoSaveSettings") {
                    m_generalAutoSaveSettings = value.toInt();
                } else if(name == "CompactSettings") {
                    m_generalCompactSettings = value.toInt();
                } else if(name == "DisableAllAnimations") {
                    m_generalDisableAllAnimations = value.toInt();
                } else if(name == "ExtensionsAllowUntrusted") {
                    QString val = value.toString();
                    if(val.contains(":://::"))
                        m_generalExtensionsAllowUntrusted = val.split(":://::");
                    else if(!val.isEmpty())
                        m_generalExtensionsAllowUntrusted = QStringList() << val;
                    else
                        m_generalExtensionsAllowUntrusted = QStringList();
                } else if(name == "ExtensionsEnabled") {
                    QString val = value.toString();
                    if(val.contains(":://::"))
                        m_generalExtensionsEnabled = val.split(":://::");
                    else if(!val.isEmpty())
                        m_generalExtensionsEnabled = QStringList() << val;
                    else
                        m_generalExtensionsEnabled = QStringList();
                } else if(name == "ExtensionsFloatingSetup") {
                    QString val = value.toString();
                    if(val.contains(":://::"))
                        m_generalExtensionsFloatingSetup = val.split(":://::");
                    else if(!val.isEmpty())
                        m_generalExtensionsFloatingSetup = QStringList() << val;
                    else
                        m_generalExtensionsFloatingSetup = QStringList();
                } else if(name == "InterfaceVariant") {
                    m_generalInterfaceVariant = value.toString();
                } else if(name == "Version") {
                    m_generalVersion = value.toString();
                }
            // table: imageview
            } else if(table == "imageview") {
                if(name == "AdvancedSortAscending") {
                    m_imageviewAdvancedSortAscending = value.toInt();
                } else if(name == "AdvancedSortCriteria") {
                    m_imageviewAdvancedSortCriteria = value.toString();
                } else if(name == "AdvancedSortDateCriteria") {
                    QString val = value.toString();
                    if(val.contains(":://::"))
                        m_imageviewAdvancedSortDateCriteria = val.split(":://::");
                    else if(!val.isEmpty())
                        m_imageviewAdvancedSortDateCriteria = QStringList() << val;
                    else
                        m_imageviewAdvancedSortDateCriteria = QStringList();
                } else if(name == "AdvancedSortQuality") {
                    m_imageviewAdvancedSortQuality = value.toString();
                } else if(name == "AlwaysActualSize") {
                    m_imageviewAlwaysActualSize = value.toInt();
                } else if(name == "AnimationDuration") {
                    m_imageviewAnimationDuration = value.toInt();
                } else if(name == "AnimationType") {
                    m_imageviewAnimationType = value.toString();
                } else if(name == "Cache") {
                    m_imageviewCache = value.toInt();
                } else if(name == "ColorSpaceContextMenu") {
                    QString val = value.toString();
                    if(val.contains(":://::"))
                        m_imageviewColorSpaceContextMenu = val.split(":://::");
                    else if(!val.isEmpty())
                        m_imageviewColorSpaceContextMenu = QStringList() << val;
                    else
                        m_imageviewColorSpaceContextMenu = QStringList();
                } else if(name == "ColorSpaceDefault") {
                    m_imageviewColorSpaceDefault = value.toString();
                } else if(name == "ColorSpaceEnable") {
                    m_imageviewColorSpaceEnable = value.toInt();
                } else if(name == "ColorSpaceLoadEmbedded") {
                    m_imageviewColorSpaceLoadEmbedded = value.toInt();
                } else if(name == "EscapeExitArchive") {
                    m_imageviewEscapeExitArchive = value.toInt();
                } else if(name == "EscapeExitBarcodes") {
                    m_imageviewEscapeExitBarcodes = value.toInt();
                } else if(name == "EscapeExitDocument") {
                    m_imageviewEscapeExitDocument = value.toInt();
                } else if(name == "EscapeExitFilter") {
                    m_imageviewEscapeExitFilter = value.toInt();
                } else if(name == "EscapeExitSphere") {
                    m_imageviewEscapeExitSphere = value.toInt();
                } else if(name == "FitInWindow") {
                    m_imageviewFitInWindow = value.toInt();
                } else if(name == "HideCursorTimeout") {
                    m_imageviewHideCursorTimeout = value.toInt();
                } else if(name == "InterpolationFullImage") {
                    m_imageviewInterpolationFullImage = value.toInt();
                } else if(name == "LoopThroughFolder") {
                    m_imageviewLoopThroughFolder = value.toInt();
                } else if(name == "Margin") {
                    m_imageviewMargin = value.toInt();
                } else if(name == "MinimapSizeLevel") {
                    m_imageviewMinimapSizeLevel = value.toInt();
                } else if(name == "MirrorAnimate") {
                    m_imageviewMirrorAnimate = value.toInt();
                } else if(name == "MouseWheelRepeatDelay") {
                    m_imageviewMouseWheelRepeatDelay = value.toInt();
                } else if(name == "PreloadInBackground") {
                    m_imageviewPreloadInBackground = value.toInt();
                } else if(name == "PreserveMirror") {
                    m_imageviewPreserveMirror = value.toInt();
                } else if(name == "PreserveRotation") {
                    m_imageviewPreserveRotation = value.toInt();
                } else if(name == "PreserveZoom") {
                    m_imageviewPreserveZoom = value.toInt();
                } else if(name == "RememberZoomRotationMirror") {
                    m_imageviewRememberZoomRotationMirror = value.toInt();
                } else if(name == "RescalingSmooth") {
                    m_imageviewRescalingSmooth = value.toInt();
                } else if(name == "RescalingWhichImages") {
                    m_imageviewRescalingWhichImages = value.toInt();
                } else if(name == "ResetViewAutoHideTimeout") {
                    m_imageviewResetViewAutoHideTimeout = value.toInt();
                } else if(name == "ResetViewShow") {
                    m_imageviewResetViewShow = value.toInt();
                } else if(name == "RespectDevicePixelRatio") {
                    m_imageviewRespectDevicePixelRatio = value.toInt();
                } else if(name == "ShowMinimap") {
                    m_imageviewShowMinimap = value.toInt();
                } else if(name == "SiblingFileMaxIterations") {
                    m_imageviewSiblingFileMaxIterations = value.toInt();
                } else if(name == "SiblingFileMaxLevelUp") {
                    m_imageviewSiblingFileMaxLevelUp = value.toInt();
                } else if(name == "SiblingFilemaxLevelDown") {
                    m_imageviewSiblingFilemaxLevelDown = value.toInt();
                } else if(name == "SortImagesAscending") {
                    m_imageviewSortImagesAscending = value.toInt();
                } else if(name == "SortImagesBy") {
                    m_imageviewSortImagesBy = value.toString();
                } else if(name == "TransparencyMarker") {
                    m_imageviewTransparencyMarker = value.toInt();
                } else if(name == "UseMouseLeftButtonForImageMove") {
                    m_imageviewUseMouseLeftButtonForImageMove = value.toInt();
                } else if(name == "UseMouseWheelForImageMove") {
                    m_imageviewUseMouseWheelForImageMove = value.toInt();
                } else if(name == "ZoomMax") {
                    m_imageviewZoomMax = value.toInt();
                } else if(name == "ZoomMaxEnabled") {
                    m_imageviewZoomMaxEnabled = value.toInt();
                } else if(name == "ZoomMin") {
                    m_imageviewZoomMin = value.toInt();
                } else if(name == "ZoomMinEnabled") {
                    m_imageviewZoomMinEnabled = value.toInt();
                } else if(name == "ZoomSpeed") {
                    m_imageviewZoomSpeed = value.toInt();
                } else if(name == "ZoomSpeedRelative") {
                    m_imageviewZoomSpeedRelative = value.toInt();
                } else if(name == "ZoomToCenter") {
                    m_imageviewZoomToCenter = value.toInt();
                }
            // table: interface
            } else if(table == "interface") {
                if(name == "AccentColor") {
                    m_interfaceAccentColor = value.toString();
                } else if(name == "AllowMultipleInstances") {
                    m_interfaceAllowMultipleInstances = value.toInt();
                } else if(name == "BackgroundCustomOverlay") {
                    m_interfaceBackgroundCustomOverlay = value.toInt();
                } else if(name == "BackgroundCustomOverlayColor") {
                    m_interfaceBackgroundCustomOverlayColor = value.toString();
                } else if(name == "BackgroundFullyTransparent") {
                    m_interfaceBackgroundFullyTransparent = value.toInt();
                } else if(name == "BackgroundImageCenter") {
                    m_interfaceBackgroundImageCenter = value.toInt();
                } else if(name == "BackgroundImagePath") {
                    m_interfaceBackgroundImagePath = value.toString();
                } else if(name == "BackgroundImageScale") {
                    m_interfaceBackgroundImageScale = value.toInt();
                } else if(name == "BackgroundImageScaleCrop") {
                    m_interfaceBackgroundImageScaleCrop = value.toInt();
                } else if(name == "BackgroundImageScreenshot") {
                    m_interfaceBackgroundImageScreenshot = value.toInt();
                } else if(name == "BackgroundImageStretch") {
                    m_interfaceBackgroundImageStretch = value.toInt();
                } else if(name == "BackgroundImageTile") {
                    m_interfaceBackgroundImageTile = value.toInt();
                } else if(name == "BackgroundImageUse") {
                    m_interfaceBackgroundImageUse = value.toInt();
                } else if(name == "BackgroundSolid") {
                    m_interfaceBackgroundSolid = value.toInt();
                } else if(name == "BlurElementsInBackground") {
                    m_interfaceBlurElementsInBackground = value.toInt();
                } else if(name == "CloseOnEmptyBackground") {
                    m_interfaceCloseOnEmptyBackground = value.toInt();
                } else if(name == "DoubleClickThreshold") {
                    m_interfaceDoubleClickThreshold = value.toInt();
                } else if(name == "EdgeBottomAction") {
                    m_interfaceEdgeBottomAction = value.toString();
                } else if(name == "EdgeLeftAction") {
                    m_interfaceEdgeLeftAction = value.toString();
                } else if(name == "EdgeRightAction") {
                    m_interfaceEdgeRightAction = value.toString();
                } else if(name == "EdgeTopAction") {
                    m_interfaceEdgeTopAction = value.toString();
                } else if(name == "FlickAdjustSpeed") {
                    m_interfaceFlickAdjustSpeed = value.toInt();
                } else if(name == "FlickAdjustSpeedSpeedup") {
                    m_interfaceFlickAdjustSpeedSpeedup = value.toInt();
                } else if(name == "FontBoldWeight") {
                    m_interfaceFontBoldWeight = value.toInt();
                } else if(name == "FontNormalWeight") {
                    m_interfaceFontNormalWeight = value.toInt();
                } else if(name == "HotEdgeSize") {
                    m_interfaceHotEdgeSize = value.toInt();
                } else if(name == "KeepWindowOnTop") {
                    m_interfaceKeepWindowOnTop = value.toInt();
                } else if(name == "Language") {
                    m_interfaceLanguage = value.toString();
                } else if(name == "MinimapPopout") {
                    m_interfaceMinimapPopout = value.toInt();
                } else if(name == "NavigateOnEmptyBackground") {
                    m_interfaceNavigateOnEmptyBackground = value.toInt();
                } else if(name == "NavigationFloating") {
                    m_interfaceNavigationFloating = value.toInt();
                } else if(name == "NotificationDistanceFromEdge") {
                    m_interfaceNotificationDistanceFromEdge = value.toInt();
                } else if(name == "NotificationLocation") {
                    m_interfaceNotificationLocation = value.toString();
                } else if(name == "NotificationTryNative") {
                    m_interfaceNotificationTryNative = value.toInt();
                } else if(name == "PopoutAbout") {
                    m_interfacePopoutAbout = value.toInt();
                } else if(name == "PopoutAdvancedSort") {
                    m_interfacePopoutAdvancedSort = value.toInt();
                } else if(name == "PopoutChromecast") {
                    m_interfacePopoutChromecast = value.toInt();
                } else if(name == "PopoutExport") {
                    m_interfacePopoutExport = value.toInt();
                } else if(name == "PopoutFileDelete") {
                    m_interfacePopoutFileDelete = value.toInt();
                } else if(name == "PopoutFileDialog") {
                    m_interfacePopoutFileDialog = value.toInt();
                } else if(name == "PopoutFileDialogNonModal") {
                    m_interfacePopoutFileDialogNonModal = value.toInt();
                } else if(name == "PopoutFileRename") {
                    m_interfacePopoutFileRename = value.toInt();
                } else if(name == "PopoutFilter") {
                    m_interfacePopoutFilter = value.toInt();
                } else if(name == "PopoutFind") {
                    m_interfacePopoutFind = value.toInt();
                } else if(name == "PopoutImgur") {
                    m_interfacePopoutImgur = value.toInt();
                } else if(name == "PopoutMainMenu") {
                    m_interfacePopoutMainMenu = value.toInt();
                } else if(name == "PopoutMapExplorer") {
                    m_interfacePopoutMapExplorer = value.toInt();
                } else if(name == "PopoutMapExplorerNonModal") {
                    m_interfacePopoutMapExplorerNonModal = value.toInt();
                } else if(name == "PopoutMetadata") {
                    m_interfacePopoutMetadata = value.toInt();
                } else if(name == "PopoutSettingsManager") {
                    m_interfacePopoutSettingsManager = value.toInt();
                } else if(name == "PopoutSettingsManagerNonModal") {
                    m_interfacePopoutSettingsManagerNonModal = value.toInt();
                } else if(name == "PopoutSlideshowControls") {
                    m_interfacePopoutSlideshowControls = value.toInt();
                } else if(name == "PopoutSlideshowSetup") {
                    m_interfacePopoutSlideshowSetup = value.toInt();
                } else if(name == "PopoutWhenWindowIsSmall") {
                    m_interfacePopoutWhenWindowIsSmall = value.toInt();
                } else if(name == "QuickActions") {
                    m_interfaceQuickActions = value.toInt();
                } else if(name == "QuickActionsHeight") {
                    m_interfaceQuickActionsHeight = value.toInt();
                } else if(name == "QuickActionsItems") {
                    QString val = value.toString();
                    if(val.contains(":://::"))
                        m_interfaceQuickActionsItems = val.split(":://::");
                    else if(!val.isEmpty())
                        m_interfaceQuickActionsItems = QStringList() << val;
                    else
                        m_interfaceQuickActionsItems = QStringList();
                } else if(name == "RememberLastImage") {
                    m_interfaceRememberLastImage = value.toInt();
                } else if(name == "SaveWindowGeometry") {
                    m_interfaceSaveWindowGeometry = value.toInt();
                } else if(name == "StatusInfoAutoHide") {
                    m_interfaceStatusInfoAutoHide = value.toInt();
                } else if(name == "StatusInfoAutoHideTimeout") {
                    m_interfaceStatusInfoAutoHideTimeout = value.toInt();
                } else if(name == "StatusInfoAutoHideTopEdge") {
                    m_interfaceStatusInfoAutoHideTopEdge = value.toInt();
                } else if(name == "StatusInfoFontSize") {
                    m_interfaceStatusInfoFontSize = value.toInt();
                } else if(name == "StatusInfoList") {
                    QString val = value.toString();
                    if(val.contains(":://::"))
                        m_interfaceStatusInfoList = val.split(":://::");
                    else if(!val.isEmpty())
                        m_interfaceStatusInfoList = QStringList() << val;
                    else
                        m_interfaceStatusInfoList = QStringList();
                } else if(name == "StatusInfoManageWindow") {
                    m_interfaceStatusInfoManageWindow = value.toInt();
                } else if(name == "StatusInfoPosition") {
                    m_interfaceStatusInfoPosition = value.toString();
                } else if(name == "StatusInfoShow") {
                    m_interfaceStatusInfoShow = value.toInt();
                } else if(name == "StatusInfoShowImageChange") {
                    m_interfaceStatusInfoShowImageChange = value.toInt();
                } else if(name == "TrayIcon") {
                    m_interfaceTrayIcon = value.toInt();
                } else if(name == "TrayIconHideReset") {
                    m_interfaceTrayIconHideReset = value.toInt();
                } else if(name == "TrayIconMonochrome") {
                    m_interfaceTrayIconMonochrome = value.toInt();
                } else if(name == "WindowButtonsAutoHide") {
                    m_interfaceWindowButtonsAutoHide = value.toInt();
                } else if(name == "WindowButtonsAutoHideTimeout") {
                    m_interfaceWindowButtonsAutoHideTimeout = value.toInt();
                } else if(name == "WindowButtonsAutoHideTopEdge") {
                    m_interfaceWindowButtonsAutoHideTopEdge = value.toInt();
                } else if(name == "WindowButtonsFollowAccentColor") {
                    m_interfaceWindowButtonsFollowAccentColor = value.toInt();
                } else if(name == "WindowButtonsItems") {
                    QString val = value.toString();
                    if(val.contains(":://::"))
                        m_interfaceWindowButtonsItems = val.split(":://::");
                    else if(!val.isEmpty())
                        m_interfaceWindowButtonsItems = QStringList() << val;
                    else
                        m_interfaceWindowButtonsItems = QStringList();
                } else if(name == "WindowButtonsShow") {
                    m_interfaceWindowButtonsShow = value.toInt();
                } else if(name == "WindowButtonsSize") {
                    m_interfaceWindowButtonsSize = value.toInt();
                } else if(name == "WindowDecoration") {
                    m_interfaceWindowDecoration = value.toInt();
                } else if(name == "WindowDecorationOnEmptyBackground") {
                    m_interfaceWindowDecorationOnEmptyBackground = value.toInt();
                } else if(name == "WindowMode") {
                    m_interfaceWindowMode = value.toInt();
                }
            // table: mainmenu
            } else if(table == "mainmenu") {
                if(name == "ElementHeightDynamic") {
                    m_mainmenuElementHeightDynamic = value.toInt();
                } else if(name == "ElementPosition") {
                    const QStringList parts = value.toString().split(",");
                    if(parts.length() == 2)
                        m_mainmenuElementPosition = QPointF(parts[0].toDouble(), parts[1].toDouble());
                    else
                        m_mainmenuElementPosition = QPointF(0,0);
                } else if(name == "ElementSize") {
                    const QStringList parts = value.toString().split(",");
                    if(parts.length() == 2)
                        m_mainmenuElementSize = QSizeF(parts[0].toDouble(), parts[1].toDouble());
                    else
                        m_mainmenuElementSize = QSizeF(0,0);
                } else if(name == "ElementWidth") {
                    m_mainmenuElementWidth = value.toInt();
                } else if(name == "ShowExternal") {
                    m_mainmenuShowExternal = value.toInt();
                }
            // table: mapview
            } else if(table == "mapview") {
                if(name == "CurrentPosition") {
                    const QStringList parts = value.toString().split(",");
                    if(parts.length() == 2)
                        m_mapviewCurrentPosition = QPointF(parts[0].toDouble(), parts[1].toDouble());
                    else
                        m_mapviewCurrentPosition = QPointF(0,0);
                } else if(name == "CurrentSize") {
                    const QStringList parts = value.toString().split(",");
                    if(parts.length() == 2)
                        m_mapviewCurrentSize = QSizeF(parts[0].toDouble(), parts[1].toDouble());
                    else
                        m_mapviewCurrentSize = QSizeF(0,0);
                } else if(name == "CurrentVisible") {
                    m_mapviewCurrentVisible = value.toInt();
                } else if(name == "ExplorerThumbnailsScaleCrop") {
                    m_mapviewExplorerThumbnailsScaleCrop = value.toInt();
                } else if(name == "ExplorerThumbnailsZoomLevel") {
                    m_mapviewExplorerThumbnailsZoomLevel = value.toInt();
                }
            // table: metadata
            } else if(table == "metadata") {
                if(name == "AutoRotation") {
                    m_metadataAutoRotation = value.toInt();
                } else if(name == "Copyright") {
                    m_metadataCopyright = value.toInt();
                } else if(name == "Dimensions") {
                    m_metadataDimensions = value.toInt();
                } else if(name == "ElementFloating") {
                    m_metadataElementFloating = value.toInt();
                } else if(name == "ElementHeightDynamic") {
                    m_metadataElementHeightDynamic = value.toInt();
                } else if(name == "ElementPosition") {
                    const QStringList parts = value.toString().split(",");
                    if(parts.length() == 2)
                        m_metadataElementPosition = QPointF(parts[0].toDouble(), parts[1].toDouble());
                    else
                        m_metadataElementPosition = QPointF(0,0);
                } else if(name == "ElementSize") {
                    const QStringList parts = value.toString().split(",");
                    if(parts.length() == 2)
                        m_metadataElementSize = QSizeF(parts[0].toDouble(), parts[1].toDouble());
                    else
                        m_metadataElementSize = QSizeF(0,0);
                } else if(name == "ElementVisible") {
                    m_metadataElementVisible = value.toInt();
                } else if(name == "ExposureTime") {
                    m_metadataExposureTime = value.toInt();
                } else if(name == "FLength") {
                    m_metadataFLength = value.toInt();
                } else if(name == "FNumber") {
                    m_metadataFNumber = value.toInt();
                } else if(name == "FaceTagsBorder") {
                    m_metadataFaceTagsBorder = value.toInt();
                } else if(name == "FaceTagsBorderColor") {
                    m_metadataFaceTagsBorderColor = value.toString();
                } else if(name == "FaceTagsBorderWidth") {
                    m_metadataFaceTagsBorderWidth = value.toInt();
                } else if(name == "FaceTagsEnabled") {
                    m_metadataFaceTagsEnabled = value.toInt();
                } else if(name == "FaceTagsFontSize") {
                    m_metadataFaceTagsFontSize = value.toInt();
                } else if(name == "FaceTagsVisibility") {
                    m_metadataFaceTagsVisibility = value.toInt();
                } else if(name == "FileSize") {
                    m_metadataFileSize = value.toInt();
                } else if(name == "FileType") {
                    m_metadataFileType = value.toInt();
                } else if(name == "Filename") {
                    m_metadataFilename = value.toInt();
                } else if(name == "Flash") {
                    m_metadataFlash = value.toInt();
                } else if(name == "Gps") {
                    m_metadataGps = value.toInt();
                } else if(name == "GpsMap") {
                    m_metadataGpsMap = value.toString();
                } else if(name == "ImageNumber") {
                    m_metadataImageNumber = value.toInt();
                } else if(name == "Iso") {
                    m_metadataIso = value.toInt();
                } else if(name == "Keywords") {
                    m_metadataKeywords = value.toInt();
                } else if(name == "LightSource") {
                    m_metadataLightSource = value.toInt();
                } else if(name == "Location") {
                    m_metadataLocation = value.toInt();
                } else if(name == "Make") {
                    m_metadataMake = value.toInt();
                } else if(name == "Model") {
                    m_metadataModel = value.toInt();
                } else if(name == "SceneType") {
                    m_metadataSceneType = value.toInt();
                } else if(name == "SideBar") {
                    m_metadataSideBar = value.toInt();
                } else if(name == "SideBarLocation") {
                    m_metadataSideBarLocation = value.toString();
                } else if(name == "SideBarWidth") {
                    m_metadataSideBarWidth = value.toInt();
                } else if(name == "Software") {
                    m_metadataSoftware = value.toInt();
                } else if(name == "Time") {
                    m_metadataTime = value.toInt();
                }
            // table: slideshow
            } else if(table == "slideshow") {
                if(name == "HideLabels") {
                    m_slideshowHideLabels = value.toInt();
                } else if(name == "HideWindowButtons") {
                    m_slideshowHideWindowButtons = value.toInt();
                } else if(name == "ImageTransition") {
                    m_slideshowImageTransition = value.toInt();
                } else if(name == "IncludeSubFolders") {
                    m_slideshowIncludeSubFolders = value.toInt();
                } else if(name == "Loop") {
                    m_slideshowLoop = value.toInt();
                } else if(name == "Music") {
                    m_slideshowMusic = value.toInt();
                } else if(name == "MusicFile") {
                    m_slideshowMusicFile = value.toString();
                } else if(name == "MusicFiles") {
                    QString val = value.toString();
                    if(val.contains(":://::"))
                        m_slideshowMusicFiles = val.split(":://::");
                    else if(!val.isEmpty())
                        m_slideshowMusicFiles = QStringList() << val;
                    else
                        m_slideshowMusicFiles = QStringList();
                } else if(name == "MusicShuffle") {
                    m_slideshowMusicShuffle = value.toInt();
                } else if(name == "MusicVolumeVideos") {
                    m_slideshowMusicVolumeVideos = value.toInt();
                } else if(name == "Shuffle") {
                    m_slideshowShuffle = value.toInt();
                } else if(name == "Time") {
                    m_slideshowTime = value.toInt();
                } else if(name == "TypeAnimation") {
                    m_slideshowTypeAnimation = value.toString();
                }
            // table: thumbnails
            } else if(table == "thumbnails") {
                if(name == "Cache") {
                    m_thumbnailsCache = value.toInt();
                } else if(name == "CacheBaseDirDefault") {
                    m_thumbnailsCacheBaseDirDefault = value.toInt();
                } else if(name == "CacheBaseDirLocation") {
                    m_thumbnailsCacheBaseDirLocation = value.toString();
                } else if(name == "CenterOnActive") {
                    m_thumbnailsCenterOnActive = value.toInt();
                } else if(name == "CropToFit") {
                    m_thumbnailsCropToFit = value.toInt();
                } else if(name == "Disable") {
                    m_thumbnailsDisable = value.toInt();
                } else if(name == "ExcludeDropBox") {
                    m_thumbnailsExcludeDropBox = value.toString();
                } else if(name == "ExcludeFolders") {
                    QString val = value.toString();
                    if(val.contains(":://::"))
                        m_thumbnailsExcludeFolders = val.split(":://::");
                    else if(!val.isEmpty())
                        m_thumbnailsExcludeFolders = QStringList() << val;
                    else
                        m_thumbnailsExcludeFolders = QStringList();
                } else if(name == "ExcludeNetworkShares") {
                    m_thumbnailsExcludeNetworkShares = value.toInt();
                } else if(name == "ExcludeNextcloud") {
                    m_thumbnailsExcludeNextcloud = value.toString();
                } else if(name == "ExcludeOwnCloud") {
                    m_thumbnailsExcludeOwnCloud = value.toString();
                } else if(name == "Filename") {
                    m_thumbnailsFilename = value.toInt();
                } else if(name == "FontSize") {
                    m_thumbnailsFontSize = value.toInt();
                } else if(name == "HighlightAnimation") {
                    QString val = value.toString();
                    if(val.contains(":://::"))
                        m_thumbnailsHighlightAnimation = val.split(":://::");
                    else if(!val.isEmpty())
                        m_thumbnailsHighlightAnimation = QStringList() << val;
                    else
                        m_thumbnailsHighlightAnimation = QStringList();
                } else if(name == "HighlightAnimationLiftUp") {
                    m_thumbnailsHighlightAnimationLiftUp = value.toInt();
                } else if(name == "IconsOnly") {
                    m_thumbnailsIconsOnly = value.toInt();
                } else if(name == "InactiveTransparent") {
                    m_thumbnailsInactiveTransparent = value.toInt();
                } else if(name == "MaxNumberThreads") {
                    m_thumbnailsMaxNumberThreads = value.toInt();
                } else if(name == "SameHeightVaryWidth") {
                    m_thumbnailsSameHeightVaryWidth = value.toInt();
                } else if(name == "Size") {
                    m_thumbnailsSize = value.toInt();
                } else if(name == "SmallThumbnailsKeepSmall") {
                    m_thumbnailsSmallThumbnailsKeepSmall = value.toInt();
                } else if(name == "Spacing") {
                    m_thumbnailsSpacing = value.toInt();
                } else if(name == "Tooltip") {
                    m_thumbnailsTooltip = value.toInt();
                } else if(name == "Visibility") {
                    m_thumbnailsVisibility = value.toInt();
                }
            }
        }

    }

    // make sure in the integrated interface the thumbnails are either shown top or bottom and not the sides
    if(m_generalInterfaceVariant == "integrated") {
        if(m_interfaceEdgeLeftAction == "thumbnails") {
            if(m_interfaceEdgeBottomAction.isEmpty())
                m_interfaceEdgeBottomAction = "thumbnails";
            else if(m_interfaceEdgeTopAction.isEmpty())
                m_interfaceEdgeTopAction = "thumbnails";
            m_interfaceEdgeLeftAction = "";
        }
        if(m_interfaceEdgeRightAction == "thumbnails") {
            if(m_interfaceEdgeBottomAction.isEmpty())
                m_interfaceEdgeBottomAction = "thumbnails";
            else if(m_interfaceEdgeTopAction.isEmpty())
                m_interfaceEdgeTopAction = "thumbnails";
            m_interfaceEdgeRightAction = "";
        }
    }

    // we make sure that the version is written to the user database
    // this is important in order to always be able to detect updates
    QSqlQuery query(db);
    if(!dbIsTransaction) {
        db.transaction();
        dbIsTransaction = true;
    }
    query.prepare("INSERT INTO 'general' (`name`,`value`,`datatype`) VALUES ('Version', :val, 'string') ON CONFLICT (`name`) DO UPDATE SET `value`=:valupdate");
    query.bindValue(":val", m_generalVersion);
    query.bindValue(":valupdate", m_generalVersion);
    if(!query.exec()) {
        qWarning() << "SQL Error:" << query.lastError().text();
        qWarning() << "Unable to write version to database";
        qWarning() << "Executed query:" << query.lastQuery();
    }
    dbCommitTimer->start();


}

bool PQCSettings::backupDatabase() {

    // make sure all changes are written to db
    if(dbIsTransaction) {
        QSqlDatabase db = QSqlDatabase::database("settings");
        dbCommitTimer->stop();
        db.commit();
        PQCSettingsCPP::get().readDB();
        dbIsTransaction = false;
        if(db.lastError().text().trimmed().length())
            qWarning() << "ERROR committing database:" << db.lastError().text();
    }

    // backup file
    if(QFile::exists(QString("%1.bak").arg(PQCConfigFiles::get().USERSETTINGS_DB())))
        QFile::remove(QString("%1.bak").arg(PQCConfigFiles::get().USERSETTINGS_DB()));
    QFile file(PQCConfigFiles::get().USERSETTINGS_DB());
    return file.copy(QString("%1.bak").arg(PQCConfigFiles::get().USERSETTINGS_DB()));

}

void PQCSettings::saveChangedValue(const QString &_key, const QVariant &value) {

    qDebug() << "args: key =" << _key;
    qDebug() << "args: value =" << value;
    qDebug() << "readonly =" << readonly;

    if(readonly) return;

    QSqlDatabase db = QSqlDatabase::database("settings");

    dbCommitTimer->stop();

    QString key = _key;
    QString category = "";

    for(const auto &table : std::as_const(dbtables)) {
        if(key.startsWith(table)) {
            category = table;
            key = key.remove(0, table.length());
            break;
        }
    }

    if(category.isEmpty()) {
        qWarning() << "ERROR: invalid category received:" << key;
        return;
    }

    QSqlQuery query(db);

    if(!dbIsTransaction) {
        db.transaction();
        dbIsTransaction = true;
    }

    // Using a placeholder also for table name causes an sqlite 'parameter count mismatch' error
    // the 'on conflict' cause performs an update if the value already exists and the insert thus failed
    query.prepare(QString("INSERT INTO '%1' (`name`,`value`,`datatype`) VALUES (:nme, :val, :dat) ON CONFLICT (`name`) DO UPDATE SET `value`=:valupdate").arg(category));

    query.bindValue(":nme", key);

    // we convert the value to a string
    QString val = "";
    if(value.typeId() == QMetaType::Bool) {
        val = QString::number(value.toInt());
        query.bindValue(":dat", "bool");
    } else if(value.typeId() == QMetaType::Int) {
        val = QString::number(value.toInt());
        query.bindValue(":dat", "int");
    } else if(value.typeId() == QMetaType::Double) {
        val = QString::number(value.toDouble());
        query.bindValue(":dat", "double");
    } else if(value.typeId() == QMetaType::QStringList) {
        val = value.toStringList().join(":://::");
        query.bindValue(":dat", "list");
    } else if(value.typeId() == QMetaType::QPoint) {
        val = QString("%1,%2").arg(value.toPoint().x()).arg(value.toPoint().y());
        query.bindValue(":dat", "point");
    } else if(value.typeId() == QMetaType::QPointF) {
        val = QString("%1,%2").arg(value.toPointF().x()).arg(value.toPointF().y());
        query.bindValue(":dat", "point");
    } else if(value.typeId() == QMetaType::QSize) {
        val = QString("%1,%2").arg(value.toSize().width()).arg(value.toSize().height());
        query.bindValue(":dat", "size");
    } else if(value.typeId() == QMetaType::QSizeF) {
        val = QString("%1,%2").arg(value.toSizeF().width()).arg(value.toSizeF().height());
        query.bindValue(":dat", "size");
    } else if(value.canConvert<QJSValue>() && value.value<QJSValue>().isArray()) {
        QStringList ret;
        QJSValue _val = value.value<QJSValue>();
        const int length = _val.property("length").toInt();
        for(int i = 0; i < length; ++i)
            ret << _val.property(i).toString();
        val = ret.join(":://::");
        query.bindValue(":dat", "list");
    } else {
        val = value.toString();
        query.bindValue(":dat", "string");
    }

    query.bindValue(":val", val);
    query.bindValue(":valupdate", val);

    // and update database
    if(!query.exec()) {
        qWarning() << "SQL Error:" << query.lastError().text();
        qWarning() << "Category =" << category << "- value =" << value;
        qWarning() << "Executed query:" << query.lastQuery();
    }

    dbCommitTimer->start();

}

void PQCSettings::setDefault() {

    qDebug() << "readonly =" << readonly;

    if(readonly) return;

    QSqlDatabase db = QSqlDatabase::database("settings");

    backupDatabase();

    dbCommitTimer->stop();
    if(!dbIsTransaction) {
        db.transaction();
        dbIsTransaction = true;
    }

    for(const auto &table : std::as_const(dbtables)) {

        QSqlQuery query(db);
        if(!query.exec(QString("DELETE FROM '%1'").arg(table)))
            qWarning() << "SQL Error:" << query.lastError().text();

    }

    setupFresh();

}
void PQCSettings::commitDatabase() {

    qDebug() << "";

    QSqlDatabase db = QSqlDatabase::database("settings");

    dbCommitTimer->stop();

    if(dbIsTransaction) {
        db.commit();
        PQCSettingsCPP::get().readDB();
        dbIsTransaction = false;
        if(db.lastError().text().trimmed().length())
            qWarning() << "ERROR committing database:" << db.lastError().text();
    }

}

void PQCSettings::closeDatabase() {

    qDebug() << "";

    commitDatabase();

    QSqlDatabase::database("settings").close();

}

void PQCSettings::reopenDatabase() {

    qDebug() << "";

    if(!QSqlDatabase::database("settings").open())
        qWarning() << "Unable to reopen database";

}

QString PQCSettings::verifyNameAndGetType(QString name) {

    QString tablename = "";
    QString settingname = "";

    for(auto &t : std::as_const(dbtables)) {

        if(name.startsWith(t)) {
            tablename = t;
            break;
        }

    }

    // invalid table name
    if(tablename.isEmpty())
        return "";

    settingname = name.last(name.size()-tablename.size());

    QSqlQuery query(QSqlDatabase::database("defaultsettings"));
    query.prepare(QString("SELECT datatype FROM `%1` WHERE `name`=:nme").arg(tablename));
    query.bindValue(":nme", settingname);
    if(!query.exec()) {
        qWarning() << "ERROR checking datatype for setting" << settingname;
        return "";
    }

    // invalid setting name
    if(!query.next())
        return "";

    QString ret = query.value(0).toString();
    query.clear();

    return ret;

}

void PQCSettings::setupFresh() {

    qDebug() << "";

    // table: filedialog
    m_filedialogDetailsTooltip = true;
    m_filedialogDevices = false;
    m_filedialogDevicesShowTmpfs = false;
    m_filedialogDragDropFileviewGrid = false;
    m_filedialogDragDropFileviewList = true;
    m_filedialogDragDropFileviewMasonry = false;
    m_filedialogDragDropPlaces = true;
    m_filedialogElementPadding = 1;
    m_filedialogFolderContentThumbnails = true;
    m_filedialogFolderContentThumbnailsAutoload = false;
    m_filedialogFolderContentThumbnailsLoop = true;
    m_filedialogFolderContentThumbnailsScaleCrop = true;
    m_filedialogFolderContentThumbnailsSortAscending = true;
    m_filedialogFolderContentThumbnailsSortBy = "default";
    m_filedialogFolderContentThumbnailsSpeed = 2;
    m_filedialogLabelsShowGrid = true;
    m_filedialogLabelsShowMasonry = false;
    m_filedialogLayout = "grid";
    m_filedialogPlaces = true;
    m_filedialogPlacesWidth = 290;
    m_filedialogPreview = false;
    m_filedialogPreviewBlur = false;
    m_filedialogPreviewColorIntensity = 50;
    m_filedialogPreviewCropToFit = true;
    m_filedialogPreviewHigherResolution = false;
    m_filedialogPreviewMuted = false;
    m_filedialogRememberSelection = false;
    m_filedialogShowHiddenFilesFolders = false;
    m_filedialogSingleClickSelect = false;
    m_filedialogStartupRestoreCustom = false;
    m_filedialogStartupRestoreCustomFolder = "";
    m_filedialogStartupRestoreHome = false;
    m_filedialogStartupRestorePrevious = true;
    m_filedialogThumbnailSizeFollowsGlobalThumbnails = true;
    m_filedialogThumbnails = true;
    m_filedialogThumbnailsScaleCrop = true;
    m_filedialogUseNativeFileDialog = false;
    m_filedialogZoom = 12;

    // table: filetypes
    m_filetypesAnimatedControls = true;
    m_filetypesAnimatedLeftRight = false;
    m_filetypesAnimatedSpacePause = true;
    m_filetypesArchiveAlwaysEnterAutomatically = false;
    m_filetypesArchiveControls = true;
    m_filetypesArchiveDontLoadMoreFilesThan = false;
    m_filetypesArchiveDontLoadMoreFilesThanCount = 2000;
    m_filetypesArchiveIgnoreLargerThan = false;
    m_filetypesArchiveIgnoreLargerThanSize = 2048;
    m_filetypesArchiveLeftRight = false;
    m_filetypesArchiveViewerModeExitButton = true;
    m_filetypesComicBookAlwaysEnterAutomatically = false;
    m_filetypesDocumentAlwaysEnterAutomatically = false;
    m_filetypesDocumentControls = true;
    m_filetypesDocumentLeftRight = false;
    m_filetypesDocumentViewerModeExitButton = true;
    m_filetypesExternalUnrar = false;
    m_filetypesLoadAppleLivePhotos = true;
    m_filetypesLoadMotionPhotos = true;
    m_filetypesMotionAutoPlay = true;
    m_filetypesMotionPhotoPlayPause = true;
    m_filetypesMotionSpacePause = true;
    m_filetypesPDFQuality = 150;
    m_filetypesPhotoSphereArrowKeys = false;
    m_filetypesPhotoSphereAutoLoad = true;
    m_filetypesPhotoSphereBigButton = false;
    m_filetypesPhotoSphereControls = false;
    m_filetypesPhotoSpherePanOnLoad = true;
    m_filetypesRAWUseEmbeddedIfAvailable = true;
    m_filetypesVideoAutoplay = true;
    m_filetypesVideoBackend = QStringList() << "qt" << "mpv";
    m_filetypesVideoLeftRightJumpVideo = false;
    m_filetypesVideoLoop = false;
    m_filetypesVideoSpacePause = true;
    m_filetypesVideoThumbnailer = "ffmpegthumbnailer";
    m_filetypesVideoVolume = 100;

    // table: general
    m_generalAutoSaveSettings = false;
    m_generalCompactSettings = false;
    m_generalDisableAllAnimations = false;
    m_generalExtensionsAllowUntrusted = QStringList();
    m_generalExtensionsEnabled = QStringList() << "CropImage" << "ExportImage" << "FloatingNavigation" << "Histogram" << "ImgurCom" << "MapCurrent" << "QuickActions" << "ScaleImage" << "Wallpaper" << "ThumbnailGenerator";
    m_generalExtensionsFloatingSetup = QStringList();
    m_generalInterfaceVariant = "modern";
    m_generalVersion = PQMVERSION;

    // table: imageview
    m_imageviewAdvancedSortAscending = true;
    m_imageviewAdvancedSortCriteria = "resolution";
    m_imageviewAdvancedSortDateCriteria = QStringList() << "exiforiginal" << "exifdigital" << "filecreation" << "filemodification";
    m_imageviewAdvancedSortQuality = "medium";
    m_imageviewAlwaysActualSize = false;
    m_imageviewAnimationDuration = 3;
    m_imageviewAnimationType = "opacity";
    m_imageviewCache = 512;
    m_imageviewColorSpaceContextMenu = QStringList() << "::0" << "::1" << "::2" << "::3" << "::4";
    m_imageviewColorSpaceDefault = "";
    m_imageviewColorSpaceEnable = true;
    m_imageviewColorSpaceLoadEmbedded = true;
    m_imageviewEscapeExitArchive = true;
    m_imageviewEscapeExitBarcodes = true;
    m_imageviewEscapeExitDocument = true;
    m_imageviewEscapeExitFilter = true;
    m_imageviewEscapeExitSphere = true;
    m_imageviewFitInWindow = false;
    m_imageviewHideCursorTimeout = 1;
    m_imageviewInterpolationFullImage = 1;
    m_imageviewLoopThroughFolder = true;
    m_imageviewMargin = 5;
    m_imageviewMinimapSizeLevel = 0;
    m_imageviewMirrorAnimate = true;
    m_imageviewMouseWheelRepeatDelay = 0;
    m_imageviewPreloadInBackground = 1;
    m_imageviewPreserveMirror = false;
    m_imageviewPreserveRotation = false;
    m_imageviewPreserveZoom = false;
    m_imageviewRememberZoomRotationMirror = false;
    m_imageviewRescalingSmooth = true;
    m_imageviewRescalingWhichImages = 2;
    m_imageviewResetViewAutoHideTimeout = 1000;
    m_imageviewResetViewShow = false;
    m_imageviewRespectDevicePixelRatio = true;
    m_imageviewShowMinimap = true;
    m_imageviewSiblingFileMaxIterations = 100;
    m_imageviewSiblingFileMaxLevelUp = 8;
    m_imageviewSiblingFilemaxLevelDown = 2;
    m_imageviewSortImagesAscending = true;
    m_imageviewSortImagesBy = "naturalname";
    m_imageviewTransparencyMarker = false;
    m_imageviewUseMouseLeftButtonForImageMove = true;
    m_imageviewUseMouseWheelForImageMove = false;
    m_imageviewZoomMax = 500;
    m_imageviewZoomMaxEnabled = true;
    m_imageviewZoomMin = 20;
    m_imageviewZoomMinEnabled = true;
    m_imageviewZoomSpeed = 20;
    m_imageviewZoomSpeedRelative = true;
    m_imageviewZoomToCenter = false;

    // table: interface
    m_interfaceAccentColor = "#222222";
    m_interfaceAllowMultipleInstances = false;
    m_interfaceBackgroundCustomOverlay = false;
    m_interfaceBackgroundCustomOverlayColor = "";
    m_interfaceBackgroundFullyTransparent = false;
    m_interfaceBackgroundImageCenter = false;
    m_interfaceBackgroundImagePath = "";
    m_interfaceBackgroundImageScale = true;
    m_interfaceBackgroundImageScaleCrop = false;
    m_interfaceBackgroundImageScreenshot = false;
    m_interfaceBackgroundImageStretch = false;
    m_interfaceBackgroundImageTile = false;
    m_interfaceBackgroundImageUse = false;
    m_interfaceBackgroundSolid = false;
    m_interfaceBlurElementsInBackground = true;
    m_interfaceCloseOnEmptyBackground = false;
    m_interfaceDoubleClickThreshold = 300;
    m_interfaceEdgeBottomAction = "thumbnails";
    m_interfaceEdgeLeftAction = "metadata";
    m_interfaceEdgeRightAction = "mainmenu";
    m_interfaceEdgeTopAction = "";
    m_interfaceFlickAdjustSpeed = true;
    m_interfaceFlickAdjustSpeedSpeedup = 1;
    m_interfaceFontBoldWeight = 700;
    m_interfaceFontNormalWeight = 400;
    m_interfaceHotEdgeSize = 4;
    m_interfaceKeepWindowOnTop = false;
    m_interfaceLanguage = "en";
    m_interfaceMinimapPopout = false;
    m_interfaceNavigateOnEmptyBackground = false;
    m_interfaceNavigationFloating = false;
    m_interfaceNotificationDistanceFromEdge = 40;
    m_interfaceNotificationLocation = "center";
    m_interfaceNotificationTryNative = true;
    m_interfacePopoutAbout = false;
    m_interfacePopoutAdvancedSort = true;
    m_interfacePopoutChromecast = true;
    m_interfacePopoutExport = true;
    m_interfacePopoutFileDelete = false;
    m_interfacePopoutFileDialog = false;
    m_interfacePopoutFileDialogNonModal = false;
    m_interfacePopoutFileRename = false;
    m_interfacePopoutFilter = false;
    m_interfacePopoutFind = false;
    m_interfacePopoutImgur = true;
    m_interfacePopoutMainMenu = false;
    m_interfacePopoutMapExplorer = true;
    m_interfacePopoutMapExplorerNonModal = false;
    m_interfacePopoutMetadata = false;
    m_interfacePopoutSettingsManager = false;
    m_interfacePopoutSettingsManagerNonModal = false;
    m_interfacePopoutSlideshowControls = false;
    m_interfacePopoutSlideshowSetup = true;
    m_interfacePopoutWhenWindowIsSmall = true;
    m_interfaceQuickActions = true;
    m_interfaceQuickActionsHeight = 40;
    m_interfaceQuickActionsItems = QStringList() << "rename" << "delete" << "|" << "rotateleft" << "rotateright" << "mirrorhor" << "mirrorver" << "|" << "crop" << "scale" << "|" << "close";
    m_interfaceRememberLastImage = false;
    m_interfaceSaveWindowGeometry = false;
    m_interfaceStatusInfoAutoHide = false;
    m_interfaceStatusInfoAutoHideTimeout = 1000;
    m_interfaceStatusInfoAutoHideTopEdge = false;
    m_interfaceStatusInfoFontSize = 10;
    m_interfaceStatusInfoList = QStringList() << "counter" << "filename" << "zoom" << "rotation";
    m_interfaceStatusInfoManageWindow = false;
    m_interfaceStatusInfoPosition = "left";
    m_interfaceStatusInfoShow = true;
    m_interfaceStatusInfoShowImageChange = true;
    m_interfaceTrayIcon = 0;
    m_interfaceTrayIconHideReset = false;
    m_interfaceTrayIconMonochrome = true;
    m_interfaceWindowButtonsAutoHide = false;
    m_interfaceWindowButtonsAutoHideTimeout = 1000;
    m_interfaceWindowButtonsAutoHideTopEdge = false;
    m_interfaceWindowButtonsFollowAccentColor = false;
    m_interfaceWindowButtonsItems = QStringList() << "left_0|0|0" << "right_0|0|0" << "menu_0|0|0" << "ontop_0|1|1" << "fullscreen_0|0|1";
    m_interfaceWindowButtonsShow = true;
    m_interfaceWindowButtonsSize = 10;
    m_interfaceWindowDecoration = true;
    m_interfaceWindowDecorationOnEmptyBackground = false;
    m_interfaceWindowMode = true;

    // table: mainmenu
    m_mainmenuElementHeightDynamic = true;
    m_mainmenuElementPosition = QPointF(100, 100);
    m_mainmenuElementSize = QSizeF(450, 900);
    m_mainmenuElementWidth = 450;
    m_mainmenuShowExternal = false;

    // table: mapview
    m_mapviewCurrentPosition = QPointF(200, 200);
    m_mapviewCurrentSize = QSizeF(400, 300);
    m_mapviewCurrentVisible = false;
    m_mapviewExplorerThumbnailsScaleCrop = true;
    m_mapviewExplorerThumbnailsZoomLevel = 20;

    // table: metadata
    m_metadataAutoRotation = true;
    m_metadataCopyright = false;
    m_metadataDimensions = true;
    m_metadataElementFloating = false;
    m_metadataElementHeightDynamic = true;
    m_metadataElementPosition = QPointF(100, 100);
    m_metadataElementSize = QSizeF(400, 700);
    m_metadataElementVisible = false;
    m_metadataExposureTime = true;
    m_metadataFLength = true;
    m_metadataFNumber = true;
    m_metadataFaceTagsBorder = false;
    m_metadataFaceTagsBorderColor = "#44ff0000";
    m_metadataFaceTagsBorderWidth = 3;
    m_metadataFaceTagsEnabled = true;
    m_metadataFaceTagsFontSize = 10;
    m_metadataFaceTagsVisibility = 1;
    m_metadataFileSize = true;
    m_metadataFileType = true;
    m_metadataFilename = true;
    m_metadataFlash = true;
    m_metadataGps = true;
    m_metadataGpsMap = "openstreetmap.org";
    m_metadataImageNumber = true;
    m_metadataIso = true;
    m_metadataKeywords = false;
    m_metadataLightSource = false;
    m_metadataLocation = false;
    m_metadataMake = true;
    m_metadataModel = true;
    m_metadataSceneType = true;
    m_metadataSideBar = true;
    m_metadataSideBarLocation = "right";
    m_metadataSideBarWidth = 300;
    m_metadataSoftware = true;
    m_metadataTime = true;

    // table: slideshow
    m_slideshowHideLabels = true;
    m_slideshowHideWindowButtons = false;
    m_slideshowImageTransition = 4;
    m_slideshowIncludeSubFolders = false;
    m_slideshowLoop = true;
    m_slideshowMusic = false;
    m_slideshowMusicFile = "";
    m_slideshowMusicFiles = QStringList();
    m_slideshowMusicShuffle = false;
    m_slideshowMusicVolumeVideos = 1;
    m_slideshowShuffle = false;
    m_slideshowTime = 5;
    m_slideshowTypeAnimation = "opacity";

    // table: thumbnails
    m_thumbnailsCache = true;
    m_thumbnailsCacheBaseDirDefault = true;
    m_thumbnailsCacheBaseDirLocation = "";
    m_thumbnailsCenterOnActive = false;
    m_thumbnailsCropToFit = true;
    m_thumbnailsDisable = false;
    m_thumbnailsExcludeDropBox = "";
    m_thumbnailsExcludeFolders = QStringList();
    m_thumbnailsExcludeNetworkShares = true;
    m_thumbnailsExcludeNextcloud = "";
    m_thumbnailsExcludeOwnCloud = "";
    m_thumbnailsFilename = true;
    m_thumbnailsFontSize = 7;
    m_thumbnailsHighlightAnimation = QStringList() << "liftup";
    m_thumbnailsHighlightAnimationLiftUp = 15;
    m_thumbnailsIconsOnly = false;
    m_thumbnailsInactiveTransparent = true;
    m_thumbnailsMaxNumberThreads = 4;
    m_thumbnailsSameHeightVaryWidth = false;
    m_thumbnailsSize = 14;
    m_thumbnailsSmallThumbnailsKeepSmall = true;
    m_thumbnailsSpacing = 2;
    m_thumbnailsTooltip = true;
    m_thumbnailsVisibility = 0;

#ifdef Q_OS_WIN
    // these defaults are different on Windows as on Linux
    m_filedialogDevices = true;
#endif

    // the window decoration on Gnome is a bit weird
    // that's why we disable it by default
    if(qgetenv("XDG_CURRENT_DESKTOP").contains("GNOME"))
        m_interfaceWindowDecoration = false;

}


void PQCSettings::resetToDefault() {

    // table: filedialog
    setDefaultForFiledialogDetailsTooltip();
    setDefaultForFiledialogDevices();
    setDefaultForFiledialogDevicesShowTmpfs();
    setDefaultForFiledialogDragDropFileviewGrid();
    setDefaultForFiledialogDragDropFileviewList();
    setDefaultForFiledialogDragDropFileviewMasonry();
    setDefaultForFiledialogDragDropPlaces();
    setDefaultForFiledialogElementPadding();
    setDefaultForFiledialogFolderContentThumbnails();
    setDefaultForFiledialogFolderContentThumbnailsAutoload();
    setDefaultForFiledialogFolderContentThumbnailsLoop();
    setDefaultForFiledialogFolderContentThumbnailsScaleCrop();
    setDefaultForFiledialogFolderContentThumbnailsSortAscending();
    setDefaultForFiledialogFolderContentThumbnailsSortBy();
    setDefaultForFiledialogFolderContentThumbnailsSpeed();
    setDefaultForFiledialogLabelsShowGrid();
    setDefaultForFiledialogLabelsShowMasonry();
    setDefaultForFiledialogLayout();
    setDefaultForFiledialogPlaces();
    setDefaultForFiledialogPlacesWidth();
    setDefaultForFiledialogPreview();
    setDefaultForFiledialogPreviewBlur();
    setDefaultForFiledialogPreviewColorIntensity();
    setDefaultForFiledialogPreviewCropToFit();
    setDefaultForFiledialogPreviewHigherResolution();
    setDefaultForFiledialogPreviewMuted();
    setDefaultForFiledialogRememberSelection();
    setDefaultForFiledialogShowHiddenFilesFolders();
    setDefaultForFiledialogSingleClickSelect();
    setDefaultForFiledialogStartupRestoreCustom();
    setDefaultForFiledialogStartupRestoreCustomFolder();
    setDefaultForFiledialogStartupRestoreHome();
    setDefaultForFiledialogStartupRestorePrevious();
    setDefaultForFiledialogThumbnailSizeFollowsGlobalThumbnails();
    setDefaultForFiledialogThumbnails();
    setDefaultForFiledialogThumbnailsScaleCrop();
    setDefaultForFiledialogUseNativeFileDialog();
    setDefaultForFiledialogZoom();

    // table: filetypes
    setDefaultForFiletypesAnimatedControls();
    setDefaultForFiletypesAnimatedLeftRight();
    setDefaultForFiletypesAnimatedSpacePause();
    setDefaultForFiletypesArchiveAlwaysEnterAutomatically();
    setDefaultForFiletypesArchiveControls();
    setDefaultForFiletypesArchiveDontLoadMoreFilesThan();
    setDefaultForFiletypesArchiveDontLoadMoreFilesThanCount();
    setDefaultForFiletypesArchiveIgnoreLargerThan();
    setDefaultForFiletypesArchiveIgnoreLargerThanSize();
    setDefaultForFiletypesArchiveLeftRight();
    setDefaultForFiletypesArchiveViewerModeExitButton();
    setDefaultForFiletypesComicBookAlwaysEnterAutomatically();
    setDefaultForFiletypesDocumentAlwaysEnterAutomatically();
    setDefaultForFiletypesDocumentControls();
    setDefaultForFiletypesDocumentLeftRight();
    setDefaultForFiletypesDocumentViewerModeExitButton();
    setDefaultForFiletypesExternalUnrar();
    setDefaultForFiletypesLoadAppleLivePhotos();
    setDefaultForFiletypesLoadMotionPhotos();
    setDefaultForFiletypesMotionAutoPlay();
    setDefaultForFiletypesMotionPhotoPlayPause();
    setDefaultForFiletypesMotionSpacePause();
    setDefaultForFiletypesPDFQuality();
    setDefaultForFiletypesPhotoSphereArrowKeys();
    setDefaultForFiletypesPhotoSphereAutoLoad();
    setDefaultForFiletypesPhotoSphereBigButton();
    setDefaultForFiletypesPhotoSphereControls();
    setDefaultForFiletypesPhotoSpherePanOnLoad();
    setDefaultForFiletypesRAWUseEmbeddedIfAvailable();
    setDefaultForFiletypesVideoAutoplay();
    setDefaultForFiletypesVideoBackend();
    setDefaultForFiletypesVideoLeftRightJumpVideo();
    setDefaultForFiletypesVideoLoop();
    setDefaultForFiletypesVideoSpacePause();
    setDefaultForFiletypesVideoThumbnailer();
    setDefaultForFiletypesVideoVolume();

    // table: general
    setDefaultForGeneralAutoSaveSettings();
    setDefaultForGeneralCompactSettings();
    setDefaultForGeneralDisableAllAnimations();
    setDefaultForGeneralExtensionsAllowUntrusted();
    setDefaultForGeneralExtensionsEnabled();
    setDefaultForGeneralExtensionsFloatingSetup();
    setDefaultForGeneralInterfaceVariant();
    setDefaultForGeneralVersion();

    // table: imageview
    setDefaultForImageviewAdvancedSortAscending();
    setDefaultForImageviewAdvancedSortCriteria();
    setDefaultForImageviewAdvancedSortDateCriteria();
    setDefaultForImageviewAdvancedSortQuality();
    setDefaultForImageviewAlwaysActualSize();
    setDefaultForImageviewAnimationDuration();
    setDefaultForImageviewAnimationType();
    setDefaultForImageviewCache();
    setDefaultForImageviewColorSpaceContextMenu();
    setDefaultForImageviewColorSpaceDefault();
    setDefaultForImageviewColorSpaceEnable();
    setDefaultForImageviewColorSpaceLoadEmbedded();
    setDefaultForImageviewEscapeExitArchive();
    setDefaultForImageviewEscapeExitBarcodes();
    setDefaultForImageviewEscapeExitDocument();
    setDefaultForImageviewEscapeExitFilter();
    setDefaultForImageviewEscapeExitSphere();
    setDefaultForImageviewFitInWindow();
    setDefaultForImageviewHideCursorTimeout();
    setDefaultForImageviewInterpolationFullImage();
    setDefaultForImageviewLoopThroughFolder();
    setDefaultForImageviewMargin();
    setDefaultForImageviewMinimapSizeLevel();
    setDefaultForImageviewMirrorAnimate();
    setDefaultForImageviewMouseWheelRepeatDelay();
    setDefaultForImageviewPreloadInBackground();
    setDefaultForImageviewPreserveMirror();
    setDefaultForImageviewPreserveRotation();
    setDefaultForImageviewPreserveZoom();
    setDefaultForImageviewRememberZoomRotationMirror();
    setDefaultForImageviewRescalingSmooth();
    setDefaultForImageviewRescalingWhichImages();
    setDefaultForImageviewResetViewAutoHideTimeout();
    setDefaultForImageviewResetViewShow();
    setDefaultForImageviewRespectDevicePixelRatio();
    setDefaultForImageviewShowMinimap();
    setDefaultForImageviewSiblingFileMaxIterations();
    setDefaultForImageviewSiblingFileMaxLevelUp();
    setDefaultForImageviewSiblingFilemaxLevelDown();
    setDefaultForImageviewSortImagesAscending();
    setDefaultForImageviewSortImagesBy();
    setDefaultForImageviewTransparencyMarker();
    setDefaultForImageviewUseMouseLeftButtonForImageMove();
    setDefaultForImageviewUseMouseWheelForImageMove();
    setDefaultForImageviewZoomMax();
    setDefaultForImageviewZoomMaxEnabled();
    setDefaultForImageviewZoomMin();
    setDefaultForImageviewZoomMinEnabled();
    setDefaultForImageviewZoomSpeed();
    setDefaultForImageviewZoomSpeedRelative();
    setDefaultForImageviewZoomToCenter();

    // table: interface
    setDefaultForInterfaceAccentColor();
    setDefaultForInterfaceAllowMultipleInstances();
    setDefaultForInterfaceBackgroundCustomOverlay();
    setDefaultForInterfaceBackgroundCustomOverlayColor();
    setDefaultForInterfaceBackgroundFullyTransparent();
    setDefaultForInterfaceBackgroundImageCenter();
    setDefaultForInterfaceBackgroundImagePath();
    setDefaultForInterfaceBackgroundImageScale();
    setDefaultForInterfaceBackgroundImageScaleCrop();
    setDefaultForInterfaceBackgroundImageScreenshot();
    setDefaultForInterfaceBackgroundImageStretch();
    setDefaultForInterfaceBackgroundImageTile();
    setDefaultForInterfaceBackgroundImageUse();
    setDefaultForInterfaceBackgroundSolid();
    setDefaultForInterfaceBlurElementsInBackground();
    setDefaultForInterfaceCloseOnEmptyBackground();
    setDefaultForInterfaceDoubleClickThreshold();
    setDefaultForInterfaceEdgeBottomAction();
    setDefaultForInterfaceEdgeLeftAction();
    setDefaultForInterfaceEdgeRightAction();
    setDefaultForInterfaceEdgeTopAction();
    setDefaultForInterfaceFlickAdjustSpeed();
    setDefaultForInterfaceFlickAdjustSpeedSpeedup();
    setDefaultForInterfaceFontBoldWeight();
    setDefaultForInterfaceFontNormalWeight();
    setDefaultForInterfaceHotEdgeSize();
    setDefaultForInterfaceKeepWindowOnTop();
    setDefaultForInterfaceLanguage();
    setDefaultForInterfaceMinimapPopout();
    setDefaultForInterfaceNavigateOnEmptyBackground();
    setDefaultForInterfaceNavigationFloating();
    setDefaultForInterfaceNotificationDistanceFromEdge();
    setDefaultForInterfaceNotificationLocation();
    setDefaultForInterfaceNotificationTryNative();
    setDefaultForInterfacePopoutAbout();
    setDefaultForInterfacePopoutAdvancedSort();
    setDefaultForInterfacePopoutChromecast();
    setDefaultForInterfacePopoutExport();
    setDefaultForInterfacePopoutFileDelete();
    setDefaultForInterfacePopoutFileDialog();
    setDefaultForInterfacePopoutFileDialogNonModal();
    setDefaultForInterfacePopoutFileRename();
    setDefaultForInterfacePopoutFilter();
    setDefaultForInterfacePopoutFind();
    setDefaultForInterfacePopoutImgur();
    setDefaultForInterfacePopoutMainMenu();
    setDefaultForInterfacePopoutMapExplorer();
    setDefaultForInterfacePopoutMapExplorerNonModal();
    setDefaultForInterfacePopoutMetadata();
    setDefaultForInterfacePopoutSettingsManager();
    setDefaultForInterfacePopoutSettingsManagerNonModal();
    setDefaultForInterfacePopoutSlideshowControls();
    setDefaultForInterfacePopoutSlideshowSetup();
    setDefaultForInterfacePopoutWhenWindowIsSmall();
    setDefaultForInterfaceQuickActions();
    setDefaultForInterfaceQuickActionsHeight();
    setDefaultForInterfaceQuickActionsItems();
    setDefaultForInterfaceRememberLastImage();
    setDefaultForInterfaceSaveWindowGeometry();
    setDefaultForInterfaceStatusInfoAutoHide();
    setDefaultForInterfaceStatusInfoAutoHideTimeout();
    setDefaultForInterfaceStatusInfoAutoHideTopEdge();
    setDefaultForInterfaceStatusInfoFontSize();
    setDefaultForInterfaceStatusInfoList();
    setDefaultForInterfaceStatusInfoManageWindow();
    setDefaultForInterfaceStatusInfoPosition();
    setDefaultForInterfaceStatusInfoShow();
    setDefaultForInterfaceStatusInfoShowImageChange();
    setDefaultForInterfaceTrayIcon();
    setDefaultForInterfaceTrayIconHideReset();
    setDefaultForInterfaceTrayIconMonochrome();
    setDefaultForInterfaceWindowButtonsAutoHide();
    setDefaultForInterfaceWindowButtonsAutoHideTimeout();
    setDefaultForInterfaceWindowButtonsAutoHideTopEdge();
    setDefaultForInterfaceWindowButtonsFollowAccentColor();
    setDefaultForInterfaceWindowButtonsItems();
    setDefaultForInterfaceWindowButtonsShow();
    setDefaultForInterfaceWindowButtonsSize();
    setDefaultForInterfaceWindowDecoration();
    setDefaultForInterfaceWindowDecorationOnEmptyBackground();
    setDefaultForInterfaceWindowMode();

    // table: mainmenu
    setDefaultForMainmenuElementHeightDynamic();
    setDefaultForMainmenuElementPosition();
    setDefaultForMainmenuElementSize();
    setDefaultForMainmenuElementWidth();
    setDefaultForMainmenuShowExternal();

    // table: mapview
    setDefaultForMapviewCurrentPosition();
    setDefaultForMapviewCurrentSize();
    setDefaultForMapviewCurrentVisible();
    setDefaultForMapviewExplorerThumbnailsScaleCrop();
    setDefaultForMapviewExplorerThumbnailsZoomLevel();

    // table: metadata
    setDefaultForMetadataAutoRotation();
    setDefaultForMetadataCopyright();
    setDefaultForMetadataDimensions();
    setDefaultForMetadataElementFloating();
    setDefaultForMetadataElementHeightDynamic();
    setDefaultForMetadataElementPosition();
    setDefaultForMetadataElementSize();
    setDefaultForMetadataElementVisible();
    setDefaultForMetadataExposureTime();
    setDefaultForMetadataFLength();
    setDefaultForMetadataFNumber();
    setDefaultForMetadataFaceTagsBorder();
    setDefaultForMetadataFaceTagsBorderColor();
    setDefaultForMetadataFaceTagsBorderWidth();
    setDefaultForMetadataFaceTagsEnabled();
    setDefaultForMetadataFaceTagsFontSize();
    setDefaultForMetadataFaceTagsVisibility();
    setDefaultForMetadataFileSize();
    setDefaultForMetadataFileType();
    setDefaultForMetadataFilename();
    setDefaultForMetadataFlash();
    setDefaultForMetadataGps();
    setDefaultForMetadataGpsMap();
    setDefaultForMetadataImageNumber();
    setDefaultForMetadataIso();
    setDefaultForMetadataKeywords();
    setDefaultForMetadataLightSource();
    setDefaultForMetadataLocation();
    setDefaultForMetadataMake();
    setDefaultForMetadataModel();
    setDefaultForMetadataSceneType();
    setDefaultForMetadataSideBar();
    setDefaultForMetadataSideBarLocation();
    setDefaultForMetadataSideBarWidth();
    setDefaultForMetadataSoftware();
    setDefaultForMetadataTime();

    // table: slideshow
    setDefaultForSlideshowHideLabels();
    setDefaultForSlideshowHideWindowButtons();
    setDefaultForSlideshowImageTransition();
    setDefaultForSlideshowIncludeSubFolders();
    setDefaultForSlideshowLoop();
    setDefaultForSlideshowMusic();
    setDefaultForSlideshowMusicFile();
    setDefaultForSlideshowMusicFiles();
    setDefaultForSlideshowMusicShuffle();
    setDefaultForSlideshowMusicVolumeVideos();
    setDefaultForSlideshowShuffle();
    setDefaultForSlideshowTime();
    setDefaultForSlideshowTypeAnimation();

    // table: thumbnails
    setDefaultForThumbnailsCache();
    setDefaultForThumbnailsCacheBaseDirDefault();
    setDefaultForThumbnailsCacheBaseDirLocation();
    setDefaultForThumbnailsCenterOnActive();
    setDefaultForThumbnailsCropToFit();
    setDefaultForThumbnailsDisable();
    setDefaultForThumbnailsExcludeDropBox();
    setDefaultForThumbnailsExcludeFolders();
    setDefaultForThumbnailsExcludeNetworkShares();
    setDefaultForThumbnailsExcludeNextcloud();
    setDefaultForThumbnailsExcludeOwnCloud();
    setDefaultForThumbnailsFilename();
    setDefaultForThumbnailsFontSize();
    setDefaultForThumbnailsHighlightAnimation();
    setDefaultForThumbnailsHighlightAnimationLiftUp();
    setDefaultForThumbnailsIconsOnly();
    setDefaultForThumbnailsInactiveTransparent();
    setDefaultForThumbnailsMaxNumberThreads();
    setDefaultForThumbnailsSameHeightVaryWidth();
    setDefaultForThumbnailsSize();
    setDefaultForThumbnailsSmallThumbnailsKeepSmall();
    setDefaultForThumbnailsSpacing();
    setDefaultForThumbnailsTooltip();
    setDefaultForThumbnailsVisibility();

}

QStringList PQCSettings::updateFromCommandLine() {

    const QStringList update = PQCNotifyCPP::get().getSettingUpdate();
    qDebug() << "update =" << update;

    if(update.length()%2 != 0)
        return {};

    // these might need some action in qml afterwards
    QStringList ret;

    const QString key = update[0];
    const QString val = update[1];

    if(key == "filedialogDetailsTooltip") {
        m_filedialogDetailsTooltip = (val.toInt()==1);
        Q_EMIT filedialogDetailsTooltipChanged();
    }
    if(key == "filedialogDevices") {
        m_filedialogDevices = (val.toInt()==1);
        Q_EMIT filedialogDevicesChanged();
    }
    if(key == "filedialogDevicesShowTmpfs") {
        m_filedialogDevicesShowTmpfs = (val.toInt()==1);
        Q_EMIT filedialogDevicesShowTmpfsChanged();
    }
    if(key == "filedialogDragDropFileviewGrid") {
        m_filedialogDragDropFileviewGrid = (val.toInt()==1);
        Q_EMIT filedialogDragDropFileviewGridChanged();
    }
    if(key == "filedialogDragDropFileviewList") {
        m_filedialogDragDropFileviewList = (val.toInt()==1);
        Q_EMIT filedialogDragDropFileviewListChanged();
    }
    if(key == "filedialogDragDropFileviewMasonry") {
        m_filedialogDragDropFileviewMasonry = (val.toInt()==1);
        Q_EMIT filedialogDragDropFileviewMasonryChanged();
    }
    if(key == "filedialogDragDropPlaces") {
        m_filedialogDragDropPlaces = (val.toInt()==1);
        Q_EMIT filedialogDragDropPlacesChanged();
    }
    if(key == "filedialogElementPadding") {
        m_filedialogElementPadding = val.toInt();
        Q_EMIT filedialogElementPaddingChanged();
    }
    if(key == "filedialogFolderContentThumbnails") {
        m_filedialogFolderContentThumbnails = (val.toInt()==1);
        Q_EMIT filedialogFolderContentThumbnailsChanged();
    }
    if(key == "filedialogFolderContentThumbnailsAutoload") {
        m_filedialogFolderContentThumbnailsAutoload = (val.toInt()==1);
        Q_EMIT filedialogFolderContentThumbnailsAutoloadChanged();
    }
    if(key == "filedialogFolderContentThumbnailsLoop") {
        m_filedialogFolderContentThumbnailsLoop = (val.toInt()==1);
        Q_EMIT filedialogFolderContentThumbnailsLoopChanged();
    }
    if(key == "filedialogFolderContentThumbnailsScaleCrop") {
        m_filedialogFolderContentThumbnailsScaleCrop = (val.toInt()==1);
        Q_EMIT filedialogFolderContentThumbnailsScaleCropChanged();
    }
    if(key == "filedialogFolderContentThumbnailsSortAscending") {
        m_filedialogFolderContentThumbnailsSortAscending = (val.toInt()==1);
        Q_EMIT filedialogFolderContentThumbnailsSortAscendingChanged();
    }
    if(key == "filedialogFolderContentThumbnailsSortBy") {
        m_filedialogFolderContentThumbnailsSortBy = val;
        Q_EMIT filedialogFolderContentThumbnailsSortByChanged();
    }
    if(key == "filedialogFolderContentThumbnailsSpeed") {
        m_filedialogFolderContentThumbnailsSpeed = val.toInt();
        Q_EMIT filedialogFolderContentThumbnailsSpeedChanged();
    }
    if(key == "filedialogLabelsShowGrid") {
        m_filedialogLabelsShowGrid = (val.toInt()==1);
        Q_EMIT filedialogLabelsShowGridChanged();
    }
    if(key == "filedialogLabelsShowMasonry") {
        m_filedialogLabelsShowMasonry = (val.toInt()==1);
        Q_EMIT filedialogLabelsShowMasonryChanged();
    }
    if(key == "filedialogLayout") {
        m_filedialogLayout = val;
        Q_EMIT filedialogLayoutChanged();
    }
    if(key == "filedialogPlaces") {
        m_filedialogPlaces = (val.toInt()==1);
        Q_EMIT filedialogPlacesChanged();
    }
    if(key == "filedialogPlacesWidth") {
        m_filedialogPlacesWidth = val.toInt();
        Q_EMIT filedialogPlacesWidthChanged();
    }
    if(key == "filedialogPreview") {
        m_filedialogPreview = (val.toInt()==1);
        Q_EMIT filedialogPreviewChanged();
    }
    if(key == "filedialogPreviewBlur") {
        m_filedialogPreviewBlur = (val.toInt()==1);
        Q_EMIT filedialogPreviewBlurChanged();
    }
    if(key == "filedialogPreviewColorIntensity") {
        m_filedialogPreviewColorIntensity = val.toInt();
        Q_EMIT filedialogPreviewColorIntensityChanged();
    }
    if(key == "filedialogPreviewCropToFit") {
        m_filedialogPreviewCropToFit = (val.toInt()==1);
        Q_EMIT filedialogPreviewCropToFitChanged();
    }
    if(key == "filedialogPreviewHigherResolution") {
        m_filedialogPreviewHigherResolution = (val.toInt()==1);
        Q_EMIT filedialogPreviewHigherResolutionChanged();
    }
    if(key == "filedialogPreviewMuted") {
        m_filedialogPreviewMuted = (val.toInt()==1);
        Q_EMIT filedialogPreviewMutedChanged();
    }
    if(key == "filedialogRememberSelection") {
        m_filedialogRememberSelection = (val.toInt()==1);
        Q_EMIT filedialogRememberSelectionChanged();
    }
    if(key == "filedialogShowHiddenFilesFolders") {
        m_filedialogShowHiddenFilesFolders = (val.toInt()==1);
        Q_EMIT filedialogShowHiddenFilesFoldersChanged();
    }
    if(key == "filedialogSingleClickSelect") {
        m_filedialogSingleClickSelect = (val.toInt()==1);
        Q_EMIT filedialogSingleClickSelectChanged();
    }
    if(key == "filedialogStartupRestoreCustom") {
        m_filedialogStartupRestoreCustom = (val.toInt()==1);
        Q_EMIT filedialogStartupRestoreCustomChanged();
    }
    if(key == "filedialogStartupRestoreCustomFolder") {
        m_filedialogStartupRestoreCustomFolder = val;
        Q_EMIT filedialogStartupRestoreCustomFolderChanged();
    }
    if(key == "filedialogStartupRestoreHome") {
        m_filedialogStartupRestoreHome = (val.toInt()==1);
        Q_EMIT filedialogStartupRestoreHomeChanged();
    }
    if(key == "filedialogStartupRestorePrevious") {
        m_filedialogStartupRestorePrevious = (val.toInt()==1);
        Q_EMIT filedialogStartupRestorePreviousChanged();
    }
    if(key == "filedialogThumbnailSizeFollowsGlobalThumbnails") {
        m_filedialogThumbnailSizeFollowsGlobalThumbnails = (val.toInt()==1);
        Q_EMIT filedialogThumbnailSizeFollowsGlobalThumbnailsChanged();
    }
    if(key == "filedialogThumbnails") {
        m_filedialogThumbnails = (val.toInt()==1);
        Q_EMIT filedialogThumbnailsChanged();
    }
    if(key == "filedialogThumbnailsScaleCrop") {
        m_filedialogThumbnailsScaleCrop = (val.toInt()==1);
        Q_EMIT filedialogThumbnailsScaleCropChanged();
    }
    if(key == "filedialogUseNativeFileDialog") {
        m_filedialogUseNativeFileDialog = (val.toInt()==1);
        Q_EMIT filedialogUseNativeFileDialogChanged();
    }
    if(key == "filedialogZoom") {
        m_filedialogZoom = val.toInt();
        Q_EMIT filedialogZoomChanged();
    }
    if(key == "filetypesAnimatedControls") {
        m_filetypesAnimatedControls = (val.toInt()==1);
        Q_EMIT filetypesAnimatedControlsChanged();
    }
    if(key == "filetypesAnimatedLeftRight") {
        m_filetypesAnimatedLeftRight = (val.toInt()==1);
        Q_EMIT filetypesAnimatedLeftRightChanged();
    }
    if(key == "filetypesAnimatedSpacePause") {
        m_filetypesAnimatedSpacePause = (val.toInt()==1);
        Q_EMIT filetypesAnimatedSpacePauseChanged();
    }
    if(key == "filetypesArchiveAlwaysEnterAutomatically") {
        m_filetypesArchiveAlwaysEnterAutomatically = (val.toInt()==1);
        Q_EMIT filetypesArchiveAlwaysEnterAutomaticallyChanged();
    }
    if(key == "filetypesArchiveControls") {
        m_filetypesArchiveControls = (val.toInt()==1);
        Q_EMIT filetypesArchiveControlsChanged();
    }
    if(key == "filetypesArchiveDontLoadMoreFilesThan") {
        m_filetypesArchiveDontLoadMoreFilesThan = (val.toInt()==1);
        Q_EMIT filetypesArchiveDontLoadMoreFilesThanChanged();
    }
    if(key == "filetypesArchiveDontLoadMoreFilesThanCount") {
        m_filetypesArchiveDontLoadMoreFilesThanCount = val.toInt();
        Q_EMIT filetypesArchiveDontLoadMoreFilesThanCountChanged();
    }
    if(key == "filetypesArchiveIgnoreLargerThan") {
        m_filetypesArchiveIgnoreLargerThan = (val.toInt()==1);
        Q_EMIT filetypesArchiveIgnoreLargerThanChanged();
    }
    if(key == "filetypesArchiveIgnoreLargerThanSize") {
        m_filetypesArchiveIgnoreLargerThanSize = val.toInt();
        Q_EMIT filetypesArchiveIgnoreLargerThanSizeChanged();
    }
    if(key == "filetypesArchiveLeftRight") {
        m_filetypesArchiveLeftRight = (val.toInt()==1);
        Q_EMIT filetypesArchiveLeftRightChanged();
    }
    if(key == "filetypesArchiveViewerModeExitButton") {
        m_filetypesArchiveViewerModeExitButton = (val.toInt()==1);
        Q_EMIT filetypesArchiveViewerModeExitButtonChanged();
    }
    if(key == "filetypesComicBookAlwaysEnterAutomatically") {
        m_filetypesComicBookAlwaysEnterAutomatically = (val.toInt()==1);
        Q_EMIT filetypesComicBookAlwaysEnterAutomaticallyChanged();
    }
    if(key == "filetypesDocumentAlwaysEnterAutomatically") {
        m_filetypesDocumentAlwaysEnterAutomatically = (val.toInt()==1);
        Q_EMIT filetypesDocumentAlwaysEnterAutomaticallyChanged();
    }
    if(key == "filetypesDocumentControls") {
        m_filetypesDocumentControls = (val.toInt()==1);
        Q_EMIT filetypesDocumentControlsChanged();
    }
    if(key == "filetypesDocumentLeftRight") {
        m_filetypesDocumentLeftRight = (val.toInt()==1);
        Q_EMIT filetypesDocumentLeftRightChanged();
    }
    if(key == "filetypesDocumentViewerModeExitButton") {
        m_filetypesDocumentViewerModeExitButton = (val.toInt()==1);
        Q_EMIT filetypesDocumentViewerModeExitButtonChanged();
    }
    if(key == "filetypesExternalUnrar") {
        m_filetypesExternalUnrar = (val.toInt()==1);
        Q_EMIT filetypesExternalUnrarChanged();
    }
    if(key == "filetypesLoadAppleLivePhotos") {
        m_filetypesLoadAppleLivePhotos = (val.toInt()==1);
        Q_EMIT filetypesLoadAppleLivePhotosChanged();
    }
    if(key == "filetypesLoadMotionPhotos") {
        m_filetypesLoadMotionPhotos = (val.toInt()==1);
        Q_EMIT filetypesLoadMotionPhotosChanged();
    }
    if(key == "filetypesMotionAutoPlay") {
        m_filetypesMotionAutoPlay = (val.toInt()==1);
        Q_EMIT filetypesMotionAutoPlayChanged();
    }
    if(key == "filetypesMotionPhotoPlayPause") {
        m_filetypesMotionPhotoPlayPause = (val.toInt()==1);
        Q_EMIT filetypesMotionPhotoPlayPauseChanged();
    }
    if(key == "filetypesMotionSpacePause") {
        m_filetypesMotionSpacePause = (val.toInt()==1);
        Q_EMIT filetypesMotionSpacePauseChanged();
    }
    if(key == "filetypesPDFQuality") {
        m_filetypesPDFQuality = val.toInt();
        Q_EMIT filetypesPDFQualityChanged();
    }
    if(key == "filetypesPhotoSphereArrowKeys") {
        m_filetypesPhotoSphereArrowKeys = (val.toInt()==1);
        Q_EMIT filetypesPhotoSphereArrowKeysChanged();
    }
    if(key == "filetypesPhotoSphereAutoLoad") {
        m_filetypesPhotoSphereAutoLoad = (val.toInt()==1);
        Q_EMIT filetypesPhotoSphereAutoLoadChanged();
    }
    if(key == "filetypesPhotoSphereBigButton") {
        m_filetypesPhotoSphereBigButton = (val.toInt()==1);
        Q_EMIT filetypesPhotoSphereBigButtonChanged();
    }
    if(key == "filetypesPhotoSphereControls") {
        m_filetypesPhotoSphereControls = (val.toInt()==1);
        Q_EMIT filetypesPhotoSphereControlsChanged();
    }
    if(key == "filetypesPhotoSpherePanOnLoad") {
        m_filetypesPhotoSpherePanOnLoad = (val.toInt()==1);
        Q_EMIT filetypesPhotoSpherePanOnLoadChanged();
    }
    if(key == "filetypesRAWUseEmbeddedIfAvailable") {
        m_filetypesRAWUseEmbeddedIfAvailable = (val.toInt()==1);
        Q_EMIT filetypesRAWUseEmbeddedIfAvailableChanged();
    }
    if(key == "filetypesVideoAutoplay") {
        m_filetypesVideoAutoplay = (val.toInt()==1);
        Q_EMIT filetypesVideoAutoplayChanged();
    }
    if(key == "filetypesVideoBackend") {
        m_filetypesVideoBackend = val.split(":://::");
        Q_EMIT filetypesVideoBackendChanged();
    }
    if(key == "filetypesVideoLeftRightJumpVideo") {
        m_filetypesVideoLeftRightJumpVideo = (val.toInt()==1);
        Q_EMIT filetypesVideoLeftRightJumpVideoChanged();
    }
    if(key == "filetypesVideoLoop") {
        m_filetypesVideoLoop = (val.toInt()==1);
        Q_EMIT filetypesVideoLoopChanged();
    }
    if(key == "filetypesVideoSpacePause") {
        m_filetypesVideoSpacePause = (val.toInt()==1);
        Q_EMIT filetypesVideoSpacePauseChanged();
    }
    if(key == "filetypesVideoThumbnailer") {
        m_filetypesVideoThumbnailer = val;
        Q_EMIT filetypesVideoThumbnailerChanged();
    }
    if(key == "filetypesVideoVolume") {
        m_filetypesVideoVolume = val.toInt();
        Q_EMIT filetypesVideoVolumeChanged();
    }
    if(key == "generalAutoSaveSettings") {
        m_generalAutoSaveSettings = (val.toInt()==1);
        Q_EMIT generalAutoSaveSettingsChanged();
    }
    if(key == "generalCompactSettings") {
        m_generalCompactSettings = (val.toInt()==1);
        Q_EMIT generalCompactSettingsChanged();
    }
    if(key == "generalDisableAllAnimations") {
        m_generalDisableAllAnimations = (val.toInt()==1);
        Q_EMIT generalDisableAllAnimationsChanged();
    }
    if(key == "generalExtensionsAllowUntrusted") {
        m_generalExtensionsAllowUntrusted = val.split(":://::");
        Q_EMIT generalExtensionsAllowUntrustedChanged();
    }
    if(key == "generalExtensionsEnabled") {
        m_generalExtensionsEnabled = val.split(":://::");
        Q_EMIT generalExtensionsEnabledChanged();
    }
    if(key == "generalExtensionsFloatingSetup") {
        m_generalExtensionsFloatingSetup = val.split(":://::");
        Q_EMIT generalExtensionsFloatingSetupChanged();
    }
    if(key == "generalInterfaceVariant") {
        m_generalInterfaceVariant = val;
        Q_EMIT generalInterfaceVariantChanged();
    }
    if(key == "generalVersion") {
        m_generalVersion = val;
        Q_EMIT generalVersionChanged();
    }
    if(key == "imageviewAdvancedSortAscending") {
        m_imageviewAdvancedSortAscending = (val.toInt()==1);
        Q_EMIT imageviewAdvancedSortAscendingChanged();
    }
    if(key == "imageviewAdvancedSortCriteria") {
        m_imageviewAdvancedSortCriteria = val;
        Q_EMIT imageviewAdvancedSortCriteriaChanged();
    }
    if(key == "imageviewAdvancedSortDateCriteria") {
        m_imageviewAdvancedSortDateCriteria = val.split(":://::");
        Q_EMIT imageviewAdvancedSortDateCriteriaChanged();
    }
    if(key == "imageviewAdvancedSortQuality") {
        m_imageviewAdvancedSortQuality = val;
        Q_EMIT imageviewAdvancedSortQualityChanged();
    }
    if(key == "imageviewAlwaysActualSize") {
        m_imageviewAlwaysActualSize = (val.toInt()==1);
        Q_EMIT imageviewAlwaysActualSizeChanged();
    }
    if(key == "imageviewAnimationDuration") {
        m_imageviewAnimationDuration = val.toInt();
        Q_EMIT imageviewAnimationDurationChanged();
    }
    if(key == "imageviewAnimationType") {
        m_imageviewAnimationType = val;
        Q_EMIT imageviewAnimationTypeChanged();
    }
    if(key == "imageviewCache") {
        m_imageviewCache = val.toInt();
        Q_EMIT imageviewCacheChanged();
    }
    if(key == "imageviewColorSpaceContextMenu") {
        m_imageviewColorSpaceContextMenu = val.split(":://::");
        Q_EMIT imageviewColorSpaceContextMenuChanged();
    }
    if(key == "imageviewColorSpaceDefault") {
        m_imageviewColorSpaceDefault = val;
        Q_EMIT imageviewColorSpaceDefaultChanged();
    }
    if(key == "imageviewColorSpaceEnable") {
        m_imageviewColorSpaceEnable = (val.toInt()==1);
        Q_EMIT imageviewColorSpaceEnableChanged();
    }
    if(key == "imageviewColorSpaceLoadEmbedded") {
        m_imageviewColorSpaceLoadEmbedded = (val.toInt()==1);
        Q_EMIT imageviewColorSpaceLoadEmbeddedChanged();
    }
    if(key == "imageviewEscapeExitArchive") {
        m_imageviewEscapeExitArchive = (val.toInt()==1);
        Q_EMIT imageviewEscapeExitArchiveChanged();
    }
    if(key == "imageviewEscapeExitBarcodes") {
        m_imageviewEscapeExitBarcodes = (val.toInt()==1);
        Q_EMIT imageviewEscapeExitBarcodesChanged();
    }
    if(key == "imageviewEscapeExitDocument") {
        m_imageviewEscapeExitDocument = (val.toInt()==1);
        Q_EMIT imageviewEscapeExitDocumentChanged();
    }
    if(key == "imageviewEscapeExitFilter") {
        m_imageviewEscapeExitFilter = (val.toInt()==1);
        Q_EMIT imageviewEscapeExitFilterChanged();
    }
    if(key == "imageviewEscapeExitSphere") {
        m_imageviewEscapeExitSphere = (val.toInt()==1);
        Q_EMIT imageviewEscapeExitSphereChanged();
    }
    if(key == "imageviewFitInWindow") {
        m_imageviewFitInWindow = (val.toInt()==1);
        Q_EMIT imageviewFitInWindowChanged();
    }
    if(key == "imageviewHideCursorTimeout") {
        m_imageviewHideCursorTimeout = val.toInt();
        Q_EMIT imageviewHideCursorTimeoutChanged();
    }
    if(key == "imageviewInterpolationFullImage") {
        m_imageviewInterpolationFullImage = val.toInt();
        Q_EMIT imageviewInterpolationFullImageChanged();
    }
    if(key == "imageviewLoopThroughFolder") {
        m_imageviewLoopThroughFolder = (val.toInt()==1);
        Q_EMIT imageviewLoopThroughFolderChanged();
    }
    if(key == "imageviewMargin") {
        m_imageviewMargin = val.toInt();
        Q_EMIT imageviewMarginChanged();
    }
    if(key == "imageviewMinimapSizeLevel") {
        m_imageviewMinimapSizeLevel = val.toInt();
        Q_EMIT imageviewMinimapSizeLevelChanged();
    }
    if(key == "imageviewMirrorAnimate") {
        m_imageviewMirrorAnimate = (val.toInt()==1);
        Q_EMIT imageviewMirrorAnimateChanged();
    }
    if(key == "imageviewMouseWheelRepeatDelay") {
        m_imageviewMouseWheelRepeatDelay = val.toInt();
        Q_EMIT imageviewMouseWheelRepeatDelayChanged();
    }
    if(key == "imageviewPreloadInBackground") {
        m_imageviewPreloadInBackground = val.toInt();
        Q_EMIT imageviewPreloadInBackgroundChanged();
    }
    if(key == "imageviewPreserveMirror") {
        m_imageviewPreserveMirror = (val.toInt()==1);
        Q_EMIT imageviewPreserveMirrorChanged();
    }
    if(key == "imageviewPreserveRotation") {
        m_imageviewPreserveRotation = (val.toInt()==1);
        Q_EMIT imageviewPreserveRotationChanged();
    }
    if(key == "imageviewPreserveZoom") {
        m_imageviewPreserveZoom = (val.toInt()==1);
        Q_EMIT imageviewPreserveZoomChanged();
    }
    if(key == "imageviewRememberZoomRotationMirror") {
        m_imageviewRememberZoomRotationMirror = (val.toInt()==1);
        Q_EMIT imageviewRememberZoomRotationMirrorChanged();
    }
    if(key == "imageviewRescalingSmooth") {
        m_imageviewRescalingSmooth = (val.toInt()==1);
        Q_EMIT imageviewRescalingSmoothChanged();
    }
    if(key == "imageviewRescalingWhichImages") {
        m_imageviewRescalingWhichImages = val.toInt();
        Q_EMIT imageviewRescalingWhichImagesChanged();
    }
    if(key == "imageviewResetViewAutoHideTimeout") {
        m_imageviewResetViewAutoHideTimeout = val.toInt();
        Q_EMIT imageviewResetViewAutoHideTimeoutChanged();
    }
    if(key == "imageviewResetViewShow") {
        m_imageviewResetViewShow = (val.toInt()==1);
        Q_EMIT imageviewResetViewShowChanged();
    }
    if(key == "imageviewRespectDevicePixelRatio") {
        m_imageviewRespectDevicePixelRatio = (val.toInt()==1);
        Q_EMIT imageviewRespectDevicePixelRatioChanged();
    }
    if(key == "imageviewShowMinimap") {
        m_imageviewShowMinimap = (val.toInt()==1);
        Q_EMIT imageviewShowMinimapChanged();
    }
    if(key == "imageviewSiblingFileMaxIterations") {
        m_imageviewSiblingFileMaxIterations = val.toInt();
        Q_EMIT imageviewSiblingFileMaxIterationsChanged();
    }
    if(key == "imageviewSiblingFileMaxLevelUp") {
        m_imageviewSiblingFileMaxLevelUp = val.toInt();
        Q_EMIT imageviewSiblingFileMaxLevelUpChanged();
    }
    if(key == "imageviewSiblingFilemaxLevelDown") {
        m_imageviewSiblingFilemaxLevelDown = val.toInt();
        Q_EMIT imageviewSiblingFilemaxLevelDownChanged();
    }
    if(key == "imageviewSortImagesAscending") {
        m_imageviewSortImagesAscending = (val.toInt()==1);
        Q_EMIT imageviewSortImagesAscendingChanged();
    }
    if(key == "imageviewSortImagesBy") {
        m_imageviewSortImagesBy = val;
        Q_EMIT imageviewSortImagesByChanged();
    }
    if(key == "imageviewTransparencyMarker") {
        m_imageviewTransparencyMarker = (val.toInt()==1);
        Q_EMIT imageviewTransparencyMarkerChanged();
    }
    if(key == "imageviewUseMouseLeftButtonForImageMove") {
        m_imageviewUseMouseLeftButtonForImageMove = (val.toInt()==1);
        Q_EMIT imageviewUseMouseLeftButtonForImageMoveChanged();
    }
    if(key == "imageviewUseMouseWheelForImageMove") {
        m_imageviewUseMouseWheelForImageMove = (val.toInt()==1);
        Q_EMIT imageviewUseMouseWheelForImageMoveChanged();
    }
    if(key == "imageviewZoomMax") {
        m_imageviewZoomMax = val.toInt();
        Q_EMIT imageviewZoomMaxChanged();
    }
    if(key == "imageviewZoomMaxEnabled") {
        m_imageviewZoomMaxEnabled = (val.toInt()==1);
        Q_EMIT imageviewZoomMaxEnabledChanged();
    }
    if(key == "imageviewZoomMin") {
        m_imageviewZoomMin = val.toInt();
        Q_EMIT imageviewZoomMinChanged();
    }
    if(key == "imageviewZoomMinEnabled") {
        m_imageviewZoomMinEnabled = (val.toInt()==1);
        Q_EMIT imageviewZoomMinEnabledChanged();
    }
    if(key == "imageviewZoomSpeed") {
        m_imageviewZoomSpeed = val.toInt();
        Q_EMIT imageviewZoomSpeedChanged();
    }
    if(key == "imageviewZoomSpeedRelative") {
        m_imageviewZoomSpeedRelative = (val.toInt()==1);
        Q_EMIT imageviewZoomSpeedRelativeChanged();
    }
    if(key == "imageviewZoomToCenter") {
        m_imageviewZoomToCenter = (val.toInt()==1);
        Q_EMIT imageviewZoomToCenterChanged();
    }
    if(key == "interfaceAccentColor") {
        m_interfaceAccentColor = val;
        Q_EMIT interfaceAccentColorChanged();
    }
    if(key == "interfaceAllowMultipleInstances") {
        m_interfaceAllowMultipleInstances = (val.toInt()==1);
        Q_EMIT interfaceAllowMultipleInstancesChanged();
    }
    if(key == "interfaceBackgroundCustomOverlay") {
        m_interfaceBackgroundCustomOverlay = (val.toInt()==1);
        Q_EMIT interfaceBackgroundCustomOverlayChanged();
    }
    if(key == "interfaceBackgroundCustomOverlayColor") {
        m_interfaceBackgroundCustomOverlayColor = val;
        Q_EMIT interfaceBackgroundCustomOverlayColorChanged();
    }
    if(key == "interfaceBackgroundFullyTransparent") {
        m_interfaceBackgroundFullyTransparent = (val.toInt()==1);
        Q_EMIT interfaceBackgroundFullyTransparentChanged();
    }
    if(key == "interfaceBackgroundImageCenter") {
        m_interfaceBackgroundImageCenter = (val.toInt()==1);
        Q_EMIT interfaceBackgroundImageCenterChanged();
    }
    if(key == "interfaceBackgroundImagePath") {
        m_interfaceBackgroundImagePath = val;
        Q_EMIT interfaceBackgroundImagePathChanged();
    }
    if(key == "interfaceBackgroundImageScale") {
        m_interfaceBackgroundImageScale = (val.toInt()==1);
        Q_EMIT interfaceBackgroundImageScaleChanged();
    }
    if(key == "interfaceBackgroundImageScaleCrop") {
        m_interfaceBackgroundImageScaleCrop = (val.toInt()==1);
        Q_EMIT interfaceBackgroundImageScaleCropChanged();
    }
    if(key == "interfaceBackgroundImageScreenshot") {
        m_interfaceBackgroundImageScreenshot = (val.toInt()==1);
        Q_EMIT interfaceBackgroundImageScreenshotChanged();
    }
    if(key == "interfaceBackgroundImageStretch") {
        m_interfaceBackgroundImageStretch = (val.toInt()==1);
        Q_EMIT interfaceBackgroundImageStretchChanged();
    }
    if(key == "interfaceBackgroundImageTile") {
        m_interfaceBackgroundImageTile = (val.toInt()==1);
        Q_EMIT interfaceBackgroundImageTileChanged();
    }
    if(key == "interfaceBackgroundImageUse") {
        m_interfaceBackgroundImageUse = (val.toInt()==1);
        Q_EMIT interfaceBackgroundImageUseChanged();
    }
    if(key == "interfaceBackgroundSolid") {
        m_interfaceBackgroundSolid = (val.toInt()==1);
        Q_EMIT interfaceBackgroundSolidChanged();
    }
    if(key == "interfaceBlurElementsInBackground") {
        m_interfaceBlurElementsInBackground = (val.toInt()==1);
        Q_EMIT interfaceBlurElementsInBackgroundChanged();
    }
    if(key == "interfaceCloseOnEmptyBackground") {
        m_interfaceCloseOnEmptyBackground = (val.toInt()==1);
        Q_EMIT interfaceCloseOnEmptyBackgroundChanged();
    }
    if(key == "interfaceDoubleClickThreshold") {
        m_interfaceDoubleClickThreshold = val.toInt();
        Q_EMIT interfaceDoubleClickThresholdChanged();
    }
    if(key == "interfaceEdgeBottomAction") {
        m_interfaceEdgeBottomAction = val;
        Q_EMIT interfaceEdgeBottomActionChanged();
    }
    if(key == "interfaceEdgeLeftAction") {
        m_interfaceEdgeLeftAction = val;
        Q_EMIT interfaceEdgeLeftActionChanged();
    }
    if(key == "interfaceEdgeRightAction") {
        m_interfaceEdgeRightAction = val;
        Q_EMIT interfaceEdgeRightActionChanged();
    }
    if(key == "interfaceEdgeTopAction") {
        m_interfaceEdgeTopAction = val;
        Q_EMIT interfaceEdgeTopActionChanged();
    }
    if(key == "interfaceFlickAdjustSpeed") {
        m_interfaceFlickAdjustSpeed = (val.toInt()==1);
        Q_EMIT interfaceFlickAdjustSpeedChanged();
    }
    if(key == "interfaceFlickAdjustSpeedSpeedup") {
        m_interfaceFlickAdjustSpeedSpeedup = val.toInt();
        Q_EMIT interfaceFlickAdjustSpeedSpeedupChanged();
    }
    if(key == "interfaceFontBoldWeight") {
        m_interfaceFontBoldWeight = val.toInt();
        Q_EMIT interfaceFontBoldWeightChanged();
    }
    if(key == "interfaceFontNormalWeight") {
        m_interfaceFontNormalWeight = val.toInt();
        Q_EMIT interfaceFontNormalWeightChanged();
    }
    if(key == "interfaceHotEdgeSize") {
        m_interfaceHotEdgeSize = val.toInt();
        Q_EMIT interfaceHotEdgeSizeChanged();
    }
    if(key == "interfaceKeepWindowOnTop") {
        m_interfaceKeepWindowOnTop = (val.toInt()==1);
        Q_EMIT interfaceKeepWindowOnTopChanged();
    }
    if(key == "interfaceLanguage") {
        m_interfaceLanguage = val;
        Q_EMIT interfaceLanguageChanged();
        ret.append("interfaceLanguage");
    }
    if(key == "interfaceMinimapPopout") {
        m_interfaceMinimapPopout = (val.toInt()==1);
        Q_EMIT interfaceMinimapPopoutChanged();
    }
    if(key == "interfaceNavigateOnEmptyBackground") {
        m_interfaceNavigateOnEmptyBackground = (val.toInt()==1);
        Q_EMIT interfaceNavigateOnEmptyBackgroundChanged();
    }
    if(key == "interfaceNavigationFloating") {
        m_interfaceNavigationFloating = (val.toInt()==1);
        Q_EMIT interfaceNavigationFloatingChanged();
    }
    if(key == "interfaceNotificationDistanceFromEdge") {
        m_interfaceNotificationDistanceFromEdge = val.toInt();
        Q_EMIT interfaceNotificationDistanceFromEdgeChanged();
    }
    if(key == "interfaceNotificationLocation") {
        m_interfaceNotificationLocation = val;
        Q_EMIT interfaceNotificationLocationChanged();
    }
    if(key == "interfaceNotificationTryNative") {
        m_interfaceNotificationTryNative = (val.toInt()==1);
        Q_EMIT interfaceNotificationTryNativeChanged();
    }
    if(key == "interfacePopoutAbout") {
        m_interfacePopoutAbout = (val.toInt()==1);
        Q_EMIT interfacePopoutAboutChanged();
    }
    if(key == "interfacePopoutAdvancedSort") {
        m_interfacePopoutAdvancedSort = (val.toInt()==1);
        Q_EMIT interfacePopoutAdvancedSortChanged();
    }
    if(key == "interfacePopoutChromecast") {
        m_interfacePopoutChromecast = (val.toInt()==1);
        Q_EMIT interfacePopoutChromecastChanged();
    }
    if(key == "interfacePopoutExport") {
        m_interfacePopoutExport = (val.toInt()==1);
        Q_EMIT interfacePopoutExportChanged();
    }
    if(key == "interfacePopoutFileDelete") {
        m_interfacePopoutFileDelete = (val.toInt()==1);
        Q_EMIT interfacePopoutFileDeleteChanged();
    }
    if(key == "interfacePopoutFileDialog") {
        m_interfacePopoutFileDialog = (val.toInt()==1);
        Q_EMIT interfacePopoutFileDialogChanged();
    }
    if(key == "interfacePopoutFileDialogNonModal") {
        m_interfacePopoutFileDialogNonModal = (val.toInt()==1);
        Q_EMIT interfacePopoutFileDialogNonModalChanged();
    }
    if(key == "interfacePopoutFileRename") {
        m_interfacePopoutFileRename = (val.toInt()==1);
        Q_EMIT interfacePopoutFileRenameChanged();
    }
    if(key == "interfacePopoutFilter") {
        m_interfacePopoutFilter = (val.toInt()==1);
        Q_EMIT interfacePopoutFilterChanged();
    }
    if(key == "interfacePopoutFind") {
        m_interfacePopoutFind = (val.toInt()==1);
        Q_EMIT interfacePopoutFindChanged();
    }
    if(key == "interfacePopoutImgur") {
        m_interfacePopoutImgur = (val.toInt()==1);
        Q_EMIT interfacePopoutImgurChanged();
    }
    if(key == "interfacePopoutMainMenu") {
        m_interfacePopoutMainMenu = (val.toInt()==1);
        Q_EMIT interfacePopoutMainMenuChanged();
    }
    if(key == "interfacePopoutMapExplorer") {
        m_interfacePopoutMapExplorer = (val.toInt()==1);
        Q_EMIT interfacePopoutMapExplorerChanged();
    }
    if(key == "interfacePopoutMapExplorerNonModal") {
        m_interfacePopoutMapExplorerNonModal = (val.toInt()==1);
        Q_EMIT interfacePopoutMapExplorerNonModalChanged();
    }
    if(key == "interfacePopoutMetadata") {
        m_interfacePopoutMetadata = (val.toInt()==1);
        Q_EMIT interfacePopoutMetadataChanged();
    }
    if(key == "interfacePopoutSettingsManager") {
        m_interfacePopoutSettingsManager = (val.toInt()==1);
        Q_EMIT interfacePopoutSettingsManagerChanged();
    }
    if(key == "interfacePopoutSettingsManagerNonModal") {
        m_interfacePopoutSettingsManagerNonModal = (val.toInt()==1);
        Q_EMIT interfacePopoutSettingsManagerNonModalChanged();
    }
    if(key == "interfacePopoutSlideshowControls") {
        m_interfacePopoutSlideshowControls = (val.toInt()==1);
        Q_EMIT interfacePopoutSlideshowControlsChanged();
    }
    if(key == "interfacePopoutSlideshowSetup") {
        m_interfacePopoutSlideshowSetup = (val.toInt()==1);
        Q_EMIT interfacePopoutSlideshowSetupChanged();
    }
    if(key == "interfacePopoutWhenWindowIsSmall") {
        m_interfacePopoutWhenWindowIsSmall = (val.toInt()==1);
        Q_EMIT interfacePopoutWhenWindowIsSmallChanged();
    }
    if(key == "interfaceQuickActions") {
        m_interfaceQuickActions = (val.toInt()==1);
        Q_EMIT interfaceQuickActionsChanged();
    }
    if(key == "interfaceQuickActionsHeight") {
        m_interfaceQuickActionsHeight = val.toInt();
        Q_EMIT interfaceQuickActionsHeightChanged();
    }
    if(key == "interfaceQuickActionsItems") {
        m_interfaceQuickActionsItems = val.split(":://::");
        Q_EMIT interfaceQuickActionsItemsChanged();
    }
    if(key == "interfaceRememberLastImage") {
        m_interfaceRememberLastImage = (val.toInt()==1);
        Q_EMIT interfaceRememberLastImageChanged();
    }
    if(key == "interfaceSaveWindowGeometry") {
        m_interfaceSaveWindowGeometry = (val.toInt()==1);
        Q_EMIT interfaceSaveWindowGeometryChanged();
    }
    if(key == "interfaceStatusInfoAutoHide") {
        m_interfaceStatusInfoAutoHide = (val.toInt()==1);
        Q_EMIT interfaceStatusInfoAutoHideChanged();
    }
    if(key == "interfaceStatusInfoAutoHideTimeout") {
        m_interfaceStatusInfoAutoHideTimeout = val.toInt();
        Q_EMIT interfaceStatusInfoAutoHideTimeoutChanged();
    }
    if(key == "interfaceStatusInfoAutoHideTopEdge") {
        m_interfaceStatusInfoAutoHideTopEdge = (val.toInt()==1);
        Q_EMIT interfaceStatusInfoAutoHideTopEdgeChanged();
    }
    if(key == "interfaceStatusInfoFontSize") {
        m_interfaceStatusInfoFontSize = val.toInt();
        Q_EMIT interfaceStatusInfoFontSizeChanged();
    }
    if(key == "interfaceStatusInfoList") {
        m_interfaceStatusInfoList = val.split(":://::");
        Q_EMIT interfaceStatusInfoListChanged();
    }
    if(key == "interfaceStatusInfoManageWindow") {
        m_interfaceStatusInfoManageWindow = (val.toInt()==1);
        Q_EMIT interfaceStatusInfoManageWindowChanged();
    }
    if(key == "interfaceStatusInfoPosition") {
        m_interfaceStatusInfoPosition = val;
        Q_EMIT interfaceStatusInfoPositionChanged();
    }
    if(key == "interfaceStatusInfoShow") {
        m_interfaceStatusInfoShow = (val.toInt()==1);
        Q_EMIT interfaceStatusInfoShowChanged();
    }
    if(key == "interfaceStatusInfoShowImageChange") {
        m_interfaceStatusInfoShowImageChange = (val.toInt()==1);
        Q_EMIT interfaceStatusInfoShowImageChangeChanged();
    }
    if(key == "interfaceTrayIcon") {
        m_interfaceTrayIcon = val.toInt();
        Q_EMIT interfaceTrayIconChanged();
    }
    if(key == "interfaceTrayIconHideReset") {
        m_interfaceTrayIconHideReset = (val.toInt()==1);
        Q_EMIT interfaceTrayIconHideResetChanged();
    }
    if(key == "interfaceTrayIconMonochrome") {
        m_interfaceTrayIconMonochrome = (val.toInt()==1);
        Q_EMIT interfaceTrayIconMonochromeChanged();
    }
    if(key == "interfaceWindowButtonsAutoHide") {
        m_interfaceWindowButtonsAutoHide = (val.toInt()==1);
        Q_EMIT interfaceWindowButtonsAutoHideChanged();
    }
    if(key == "interfaceWindowButtonsAutoHideTimeout") {
        m_interfaceWindowButtonsAutoHideTimeout = val.toInt();
        Q_EMIT interfaceWindowButtonsAutoHideTimeoutChanged();
    }
    if(key == "interfaceWindowButtonsAutoHideTopEdge") {
        m_interfaceWindowButtonsAutoHideTopEdge = (val.toInt()==1);
        Q_EMIT interfaceWindowButtonsAutoHideTopEdgeChanged();
    }
    if(key == "interfaceWindowButtonsFollowAccentColor") {
        m_interfaceWindowButtonsFollowAccentColor = (val.toInt()==1);
        Q_EMIT interfaceWindowButtonsFollowAccentColorChanged();
    }
    if(key == "interfaceWindowButtonsItems") {
        m_interfaceWindowButtonsItems = val.split(":://::");
        Q_EMIT interfaceWindowButtonsItemsChanged();
    }
    if(key == "interfaceWindowButtonsShow") {
        m_interfaceWindowButtonsShow = (val.toInt()==1);
        Q_EMIT interfaceWindowButtonsShowChanged();
    }
    if(key == "interfaceWindowButtonsSize") {
        m_interfaceWindowButtonsSize = val.toInt();
        Q_EMIT interfaceWindowButtonsSizeChanged();
    }
    if(key == "interfaceWindowDecoration") {
        m_interfaceWindowDecoration = (val.toInt()==1);
        Q_EMIT interfaceWindowDecorationChanged();
    }
    if(key == "interfaceWindowDecorationOnEmptyBackground") {
        m_interfaceWindowDecorationOnEmptyBackground = (val.toInt()==1);
        Q_EMIT interfaceWindowDecorationOnEmptyBackgroundChanged();
    }
    if(key == "interfaceWindowMode") {
        m_interfaceWindowMode = (val.toInt()==1);
        Q_EMIT interfaceWindowModeChanged();
    }
    if(key == "mainmenuElementHeightDynamic") {
        m_mainmenuElementHeightDynamic = (val.toInt()==1);
        Q_EMIT mainmenuElementHeightDynamicChanged();
    }
    if(key == "mainmenuElementPosition") {
        QStringList parts = val.split(",");
        if(parts.length() != 2)
            return ret;
        m_mainmenuElementPosition = QPointF(parts[0].toInt(), parts[1].toInt());
        Q_EMIT mainmenuElementPositionChanged();
    }
    if(key == "mainmenuElementSize") {
        QStringList parts = val.split(",");
        if(parts.length() != 2)
            return ret;
        m_mainmenuElementSize = QSizeF(parts[0].toInt(), parts[1].toInt());
        Q_EMIT mainmenuElementSizeChanged();
    }
    if(key == "mainmenuElementWidth") {
        m_mainmenuElementWidth = val.toInt();
        Q_EMIT mainmenuElementWidthChanged();
    }
    if(key == "mainmenuShowExternal") {
        m_mainmenuShowExternal = (val.toInt()==1);
        Q_EMIT mainmenuShowExternalChanged();
    }
    if(key == "mapviewCurrentPosition") {
        QStringList parts = val.split(",");
        if(parts.length() != 2)
            return ret;
        m_mapviewCurrentPosition = QPointF(parts[0].toInt(), parts[1].toInt());
        Q_EMIT mapviewCurrentPositionChanged();
    }
    if(key == "mapviewCurrentSize") {
        QStringList parts = val.split(",");
        if(parts.length() != 2)
            return ret;
        m_mapviewCurrentSize = QSizeF(parts[0].toInt(), parts[1].toInt());
        Q_EMIT mapviewCurrentSizeChanged();
    }
    if(key == "mapviewCurrentVisible") {
        m_mapviewCurrentVisible = (val.toInt()==1);
        Q_EMIT mapviewCurrentVisibleChanged();
    }
    if(key == "mapviewExplorerThumbnailsScaleCrop") {
        m_mapviewExplorerThumbnailsScaleCrop = (val.toInt()==1);
        Q_EMIT mapviewExplorerThumbnailsScaleCropChanged();
    }
    if(key == "mapviewExplorerThumbnailsZoomLevel") {
        m_mapviewExplorerThumbnailsZoomLevel = val.toInt();
        Q_EMIT mapviewExplorerThumbnailsZoomLevelChanged();
    }
    if(key == "metadataAutoRotation") {
        m_metadataAutoRotation = (val.toInt()==1);
        Q_EMIT metadataAutoRotationChanged();
    }
    if(key == "metadataCopyright") {
        m_metadataCopyright = (val.toInt()==1);
        Q_EMIT metadataCopyrightChanged();
    }
    if(key == "metadataDimensions") {
        m_metadataDimensions = (val.toInt()==1);
        Q_EMIT metadataDimensionsChanged();
    }
    if(key == "metadataElementFloating") {
        m_metadataElementFloating = (val.toInt()==1);
        Q_EMIT metadataElementFloatingChanged();
    }
    if(key == "metadataElementHeightDynamic") {
        m_metadataElementHeightDynamic = (val.toInt()==1);
        Q_EMIT metadataElementHeightDynamicChanged();
    }
    if(key == "metadataElementPosition") {
        QStringList parts = val.split(",");
        if(parts.length() != 2)
            return ret;
        m_metadataElementPosition = QPointF(parts[0].toInt(), parts[1].toInt());
        Q_EMIT metadataElementPositionChanged();
    }
    if(key == "metadataElementSize") {
        QStringList parts = val.split(",");
        if(parts.length() != 2)
            return ret;
        m_metadataElementSize = QSizeF(parts[0].toInt(), parts[1].toInt());
        Q_EMIT metadataElementSizeChanged();
    }
    if(key == "metadataElementVisible") {
        m_metadataElementVisible = (val.toInt()==1);
        Q_EMIT metadataElementVisibleChanged();
    }
    if(key == "metadataExposureTime") {
        m_metadataExposureTime = (val.toInt()==1);
        Q_EMIT metadataExposureTimeChanged();
    }
    if(key == "metadataFLength") {
        m_metadataFLength = (val.toInt()==1);
        Q_EMIT metadataFLengthChanged();
    }
    if(key == "metadataFNumber") {
        m_metadataFNumber = (val.toInt()==1);
        Q_EMIT metadataFNumberChanged();
    }
    if(key == "metadataFaceTagsBorder") {
        m_metadataFaceTagsBorder = (val.toInt()==1);
        Q_EMIT metadataFaceTagsBorderChanged();
    }
    if(key == "metadataFaceTagsBorderColor") {
        m_metadataFaceTagsBorderColor = val;
        Q_EMIT metadataFaceTagsBorderColorChanged();
    }
    if(key == "metadataFaceTagsBorderWidth") {
        m_metadataFaceTagsBorderWidth = val.toInt();
        Q_EMIT metadataFaceTagsBorderWidthChanged();
    }
    if(key == "metadataFaceTagsEnabled") {
        m_metadataFaceTagsEnabled = (val.toInt()==1);
        Q_EMIT metadataFaceTagsEnabledChanged();
    }
    if(key == "metadataFaceTagsFontSize") {
        m_metadataFaceTagsFontSize = val.toInt();
        Q_EMIT metadataFaceTagsFontSizeChanged();
    }
    if(key == "metadataFaceTagsVisibility") {
        m_metadataFaceTagsVisibility = val.toInt();
        Q_EMIT metadataFaceTagsVisibilityChanged();
    }
    if(key == "metadataFileSize") {
        m_metadataFileSize = (val.toInt()==1);
        Q_EMIT metadataFileSizeChanged();
    }
    if(key == "metadataFileType") {
        m_metadataFileType = (val.toInt()==1);
        Q_EMIT metadataFileTypeChanged();
    }
    if(key == "metadataFilename") {
        m_metadataFilename = (val.toInt()==1);
        Q_EMIT metadataFilenameChanged();
    }
    if(key == "metadataFlash") {
        m_metadataFlash = (val.toInt()==1);
        Q_EMIT metadataFlashChanged();
    }
    if(key == "metadataGps") {
        m_metadataGps = (val.toInt()==1);
        Q_EMIT metadataGpsChanged();
    }
    if(key == "metadataGpsMap") {
        m_metadataGpsMap = val;
        Q_EMIT metadataGpsMapChanged();
    }
    if(key == "metadataImageNumber") {
        m_metadataImageNumber = (val.toInt()==1);
        Q_EMIT metadataImageNumberChanged();
    }
    if(key == "metadataIso") {
        m_metadataIso = (val.toInt()==1);
        Q_EMIT metadataIsoChanged();
    }
    if(key == "metadataKeywords") {
        m_metadataKeywords = (val.toInt()==1);
        Q_EMIT metadataKeywordsChanged();
    }
    if(key == "metadataLightSource") {
        m_metadataLightSource = (val.toInt()==1);
        Q_EMIT metadataLightSourceChanged();
    }
    if(key == "metadataLocation") {
        m_metadataLocation = (val.toInt()==1);
        Q_EMIT metadataLocationChanged();
    }
    if(key == "metadataMake") {
        m_metadataMake = (val.toInt()==1);
        Q_EMIT metadataMakeChanged();
    }
    if(key == "metadataModel") {
        m_metadataModel = (val.toInt()==1);
        Q_EMIT metadataModelChanged();
    }
    if(key == "metadataSceneType") {
        m_metadataSceneType = (val.toInt()==1);
        Q_EMIT metadataSceneTypeChanged();
    }
    if(key == "metadataSideBar") {
        m_metadataSideBar = (val.toInt()==1);
        Q_EMIT metadataSideBarChanged();
    }
    if(key == "metadataSideBarLocation") {
        m_metadataSideBarLocation = val;
        Q_EMIT metadataSideBarLocationChanged();
    }
    if(key == "metadataSideBarWidth") {
        m_metadataSideBarWidth = val.toInt();
        Q_EMIT metadataSideBarWidthChanged();
    }
    if(key == "metadataSoftware") {
        m_metadataSoftware = (val.toInt()==1);
        Q_EMIT metadataSoftwareChanged();
    }
    if(key == "metadataTime") {
        m_metadataTime = (val.toInt()==1);
        Q_EMIT metadataTimeChanged();
    }
    if(key == "slideshowHideLabels") {
        m_slideshowHideLabels = (val.toInt()==1);
        Q_EMIT slideshowHideLabelsChanged();
    }
    if(key == "slideshowHideWindowButtons") {
        m_slideshowHideWindowButtons = (val.toInt()==1);
        Q_EMIT slideshowHideWindowButtonsChanged();
    }
    if(key == "slideshowImageTransition") {
        m_slideshowImageTransition = val.toInt();
        Q_EMIT slideshowImageTransitionChanged();
    }
    if(key == "slideshowIncludeSubFolders") {
        m_slideshowIncludeSubFolders = (val.toInt()==1);
        Q_EMIT slideshowIncludeSubFoldersChanged();
    }
    if(key == "slideshowLoop") {
        m_slideshowLoop = (val.toInt()==1);
        Q_EMIT slideshowLoopChanged();
    }
    if(key == "slideshowMusic") {
        m_slideshowMusic = (val.toInt()==1);
        Q_EMIT slideshowMusicChanged();
    }
    if(key == "slideshowMusicFile") {
        m_slideshowMusicFile = val;
        Q_EMIT slideshowMusicFileChanged();
    }
    if(key == "slideshowMusicFiles") {
        m_slideshowMusicFiles = val.split(":://::");
        Q_EMIT slideshowMusicFilesChanged();
    }
    if(key == "slideshowMusicShuffle") {
        m_slideshowMusicShuffle = (val.toInt()==1);
        Q_EMIT slideshowMusicShuffleChanged();
    }
    if(key == "slideshowMusicVolumeVideos") {
        m_slideshowMusicVolumeVideos = val.toInt();
        Q_EMIT slideshowMusicVolumeVideosChanged();
    }
    if(key == "slideshowShuffle") {
        m_slideshowShuffle = (val.toInt()==1);
        Q_EMIT slideshowShuffleChanged();
    }
    if(key == "slideshowTime") {
        m_slideshowTime = val.toInt();
        Q_EMIT slideshowTimeChanged();
    }
    if(key == "slideshowTypeAnimation") {
        m_slideshowTypeAnimation = val;
        Q_EMIT slideshowTypeAnimationChanged();
    }
    if(key == "thumbnailsCache") {
        m_thumbnailsCache = (val.toInt()==1);
        Q_EMIT thumbnailsCacheChanged();
    }
    if(key == "thumbnailsCacheBaseDirDefault") {
        m_thumbnailsCacheBaseDirDefault = (val.toInt()==1);
        Q_EMIT thumbnailsCacheBaseDirDefaultChanged();
    }
    if(key == "thumbnailsCacheBaseDirLocation") {
        m_thumbnailsCacheBaseDirLocation = val;
        Q_EMIT thumbnailsCacheBaseDirLocationChanged();
    }
    if(key == "thumbnailsCenterOnActive") {
        m_thumbnailsCenterOnActive = (val.toInt()==1);
        Q_EMIT thumbnailsCenterOnActiveChanged();
    }
    if(key == "thumbnailsCropToFit") {
        m_thumbnailsCropToFit = (val.toInt()==1);
        Q_EMIT thumbnailsCropToFitChanged();
    }
    if(key == "thumbnailsDisable") {
        m_thumbnailsDisable = (val.toInt()==1);
        Q_EMIT thumbnailsDisableChanged();
    }
    if(key == "thumbnailsExcludeDropBox") {
        m_thumbnailsExcludeDropBox = val;
        Q_EMIT thumbnailsExcludeDropBoxChanged();
    }
    if(key == "thumbnailsExcludeFolders") {
        m_thumbnailsExcludeFolders = val.split(":://::");
        Q_EMIT thumbnailsExcludeFoldersChanged();
    }
    if(key == "thumbnailsExcludeNetworkShares") {
        m_thumbnailsExcludeNetworkShares = (val.toInt()==1);
        Q_EMIT thumbnailsExcludeNetworkSharesChanged();
    }
    if(key == "thumbnailsExcludeNextcloud") {
        m_thumbnailsExcludeNextcloud = val;
        Q_EMIT thumbnailsExcludeNextcloudChanged();
    }
    if(key == "thumbnailsExcludeOwnCloud") {
        m_thumbnailsExcludeOwnCloud = val;
        Q_EMIT thumbnailsExcludeOwnCloudChanged();
    }
    if(key == "thumbnailsFilename") {
        m_thumbnailsFilename = (val.toInt()==1);
        Q_EMIT thumbnailsFilenameChanged();
    }
    if(key == "thumbnailsFontSize") {
        m_thumbnailsFontSize = val.toInt();
        Q_EMIT thumbnailsFontSizeChanged();
    }
    if(key == "thumbnailsHighlightAnimation") {
        m_thumbnailsHighlightAnimation = val.split(":://::");
        Q_EMIT thumbnailsHighlightAnimationChanged();
    }
    if(key == "thumbnailsHighlightAnimationLiftUp") {
        m_thumbnailsHighlightAnimationLiftUp = val.toInt();
        Q_EMIT thumbnailsHighlightAnimationLiftUpChanged();
    }
    if(key == "thumbnailsIconsOnly") {
        m_thumbnailsIconsOnly = (val.toInt()==1);
        Q_EMIT thumbnailsIconsOnlyChanged();
    }
    if(key == "thumbnailsInactiveTransparent") {
        m_thumbnailsInactiveTransparent = (val.toInt()==1);
        Q_EMIT thumbnailsInactiveTransparentChanged();
    }
    if(key == "thumbnailsMaxNumberThreads") {
        m_thumbnailsMaxNumberThreads = val.toInt();
        Q_EMIT thumbnailsMaxNumberThreadsChanged();
    }
    if(key == "thumbnailsSameHeightVaryWidth") {
        m_thumbnailsSameHeightVaryWidth = (val.toInt()==1);
        Q_EMIT thumbnailsSameHeightVaryWidthChanged();
    }
    if(key == "thumbnailsSize") {
        m_thumbnailsSize = val.toInt();
        Q_EMIT thumbnailsSizeChanged();
    }
    if(key == "thumbnailsSmallThumbnailsKeepSmall") {
        m_thumbnailsSmallThumbnailsKeepSmall = (val.toInt()==1);
        Q_EMIT thumbnailsSmallThumbnailsKeepSmallChanged();
    }
    if(key == "thumbnailsSpacing") {
        m_thumbnailsSpacing = val.toInt();
        Q_EMIT thumbnailsSpacingChanged();
    }
    if(key == "thumbnailsTooltip") {
        m_thumbnailsTooltip = (val.toInt()==1);
        Q_EMIT thumbnailsTooltipChanged();
    }
    if(key == "thumbnailsVisibility") {
        m_thumbnailsVisibility = val.toInt();
        Q_EMIT thumbnailsVisibilityChanged();
    }

    return ret;

}
