PerformanceTab Class Reference

#include <kis_dlg_preferences.h>

Inheritance diagram for PerformanceTab:

Public Member Functions
void	load (bool requestDefault)
	PerformanceTab (QWidget *parent=0, const char *name=0)
void	save ()
	~PerformanceTab () override
Public Member Functions inherited from WdgPerformanceSettings
	WdgPerformanceSettings (QWidget *parent, const char *name)

Private Slots
void	slotFrameClonesLimitChanged (int value)
void	slotThreadsLimitChanged (int value)

Private Member Functions
int	realTilesRAM ()

Private Attributes
QScopedPointer< KisFrameRateLimitModel >	m_frameRateModel
int	m_lastUsedClonesLimit
int	m_lastUsedThreadsLimit
QVector< SliderAndSpinBoxSync * >	m_syncs

Detailed Description

Definition at line 287 of file kis_dlg_preferences.h.

Constructor & Destructor Documentation

PerformanceTab()

PerformanceTab::PerformanceTab	(	QWidget *	parent = 0,
		const char *	name = 0 )

Definition at line 1902 of file kis_dlg_preferences.cc.

    : WdgPerformanceSettings(parent, name)
    , m_frameRateModel(new KisFrameRateLimitModel())
{
    KisImageConfig cfg(true);
    const double totalRAM = cfg.totalRAM();
    lblTotalMemory->setText(KFormat().formatByteSize(totalRAM * 1024 * 1024, 0, KFormat::IECBinaryDialect, KFormat::UnitMegaByte));
 
    KisSpinBoxI18nHelper::setText(sliderMemoryLimit, i18nc("{n} is the number value, % is the percent sign", "{n}%"));
    sliderMemoryLimit->setRange(1, 100, 2);
    sliderMemoryLimit->setSingleStep(0.01);
 
    KisSpinBoxI18nHelper::setText(sliderPoolLimit, i18nc("{n} is the number value, % is the percent sign", "{n}%"));
    sliderPoolLimit->setRange(0, 20, 2);
    sliderPoolLimit->setSingleStep(0.01);
 
    KisSpinBoxI18nHelper::setText(sliderUndoLimit, i18nc("{n} is the number value, % is the percent sign", "{n}%"));
    sliderUndoLimit->setRange(0, 50, 2);
    sliderUndoLimit->setSingleStep(0.01);
 
    intMemoryLimit->setMinimumWidth(80);
    intPoolLimit->setMinimumWidth(80);
    intUndoLimit->setMinimumWidth(80);
 
    {
        formLayout->takeRow(2);
        label_5->setVisible(false);
        intPoolLimit->setVisible(false);
        sliderPoolLimit->setVisible(false);
    }
 
    SliderAndSpinBoxSync *sync1 =
        new SliderAndSpinBoxSync(sliderMemoryLimit,
                                 intMemoryLimit,
                                 getTotalRAM);
 
    sync1->slotParentValueChanged();
    m_syncs << sync1;
 
    SliderAndSpinBoxSync *sync2 =
        new SliderAndSpinBoxSync(sliderPoolLimit,
                                 intPoolLimit,
                                 std::bind(&KisIntParseSpinBox::value,
                                             intMemoryLimit));
 
 
    connect(intMemoryLimit, SIGNAL(valueChanged(int)), sync2, SLOT(slotParentValueChanged()));
    sync2->slotParentValueChanged();
    m_syncs << sync2;
 
    SliderAndSpinBoxSync *sync3 =
        new SliderAndSpinBoxSync(sliderUndoLimit,
                                 intUndoLimit,
                                 std::bind(&PerformanceTab::realTilesRAM,
                                             this));
 
 
    connect(intPoolLimit, SIGNAL(valueChanged(int)), sync3, SLOT(slotParentValueChanged()));
    connect(intMemoryLimit, SIGNAL(valueChanged(int)), sync3, SLOT(slotParentValueChanged()));
    sync3->slotParentValueChanged();
    m_syncs << sync3;
 
    sliderSwapSize->setSuffix(i18n(" GiB"));
    sliderSwapSize->setRange(1, 64);
    intSwapSize->setRange(1, 64);
 
 
    KisAcyclicSignalConnector *swapSizeConnector = new KisAcyclicSignalConnector(this);
 
    swapSizeConnector->connectForwardInt(sliderSwapSize, SIGNAL(valueChanged(int)),
                                         intSwapSize, SLOT(setValue(int)));
 
    swapSizeConnector->connectBackwardInt(intSwapSize, SIGNAL(valueChanged(int)),
                                          sliderSwapSize, SLOT(setValue(int)));
 
    swapFileLocation->setMode(KoFileDialog::OpenDirectory);
    swapFileLocation->setConfigurationName("swapfile_location");
    swapFileLocation->setFileName(cfg.swapDir());
 
    sliderThreadsLimit->setRange(1, QThread::idealThreadCount());
    sliderFrameClonesLimit->setRange(1, QThread::idealThreadCount());
 
    sliderFrameTimeout->setRange(5, 600);
    sliderFrameTimeout->setSuffix(i18nc("suffix for \"seconds\"", " sec"));
    sliderFrameTimeout->setValue(cfg.frameRenderingTimeout() / 1000);
 
    sliderFpsLimit->setSuffix(i18n(" fps"));
 
    KisWidgetConnectionUtils::connectControlState(sliderFpsLimit, m_frameRateModel.data(), "frameRateState", "frameRate");
    KisWidgetConnectionUtils::connectControl(chkDetectFps, m_frameRateModel.data(), "detectFrameRate");
 
    connect(sliderThreadsLimit, SIGNAL(valueChanged(int)), SLOT(slotThreadsLimitChanged(int)));
    connect(sliderFrameClonesLimit, SIGNAL(valueChanged(int)), SLOT(slotFrameClonesLimitChanged(int)));
 
    intCachedFramesSizeLimit->setRange(256, 10000);
    intCachedFramesSizeLimit->setSuffix(i18n(" px"));
    intCachedFramesSizeLimit->setSingleStep(1);
    intCachedFramesSizeLimit->setPageStep(1000);
 
    intRegionOfInterestMargin->setRange(1, 100);
    KisSpinBoxI18nHelper::setText(intRegionOfInterestMargin,
                                  i18nc("{n} is the number value, % is the percent sign", "{n}%"));
    intRegionOfInterestMargin->setSingleStep(1);
    intRegionOfInterestMargin->setPageStep(10);
 
    connect(chkCachedFramesSizeLimit, SIGNAL(toggled(bool)), intCachedFramesSizeLimit, SLOT(setEnabled(bool)));
    connect(chkUseRegionOfInterest, SIGNAL(toggled(bool)), intRegionOfInterestMargin, SLOT(setEnabled(bool)));
 
    connect(chkTransformToolUseInStackPreview, SIGNAL(toggled(bool)), chkTransformToolForceLodMode, SLOT(setEnabled(bool)));
 
#ifndef Q_OS_WIN
    // AVX workaround is needed on Windows+GCC only
    chkDisableAVXOptimizations->setVisible(false);
#endif
 
    load(false);
}

References KisAcyclicSignalConnector::connectBackwardInt(), KisWidgetConnectionUtils::connectControl(), KisWidgetConnectionUtils::connectControlState(), KisAcyclicSignalConnector::connectForwardInt(), KisImageConfig::frameRenderingTimeout(), getTotalRAM(), load(), m_frameRateModel, m_syncs, KoFileDialog::OpenDirectory, realTilesRAM(), KisSpinBoxI18nHelper::setText(), slotFrameClonesLimitChanged(), SliderAndSpinBoxSync::slotParentValueChanged(), slotThreadsLimitChanged(), KisImageConfig::swapDir(), and KisImageConfig::totalRAM().

~PerformanceTab()

PerformanceTab::~PerformanceTab ( )

override

Definition at line 2020 of file kis_dlg_preferences.cc.

{
    qDeleteAll(m_syncs);
}

References m_syncs.

Member Function Documentation

load()

void PerformanceTab::load

(

bool

requestDefault

)

Definition at line 2025 of file kis_dlg_preferences.cc.

{
    KisImageConfig cfg(true);
 
    sliderMemoryLimit->setValue(cfg.memoryHardLimitPercent(requestDefault));
    sliderPoolLimit->setValue(cfg.memoryPoolLimitPercent(requestDefault));
    sliderUndoLimit->setValue(cfg.memorySoftLimitPercent(requestDefault));
 
    chkPerformanceLogging->setChecked(cfg.enablePerfLog(requestDefault));
    chkProgressReporting->setChecked(cfg.enableProgressReporting(requestDefault));
 
    sliderSwapSize->setValue(cfg.maxSwapSize(requestDefault) / 1024);
    swapFileLocation->setFileName(cfg.swapDir(requestDefault));
 
    m_lastUsedThreadsLimit = cfg.maxNumberOfThreads(requestDefault);
    m_lastUsedClonesLimit = cfg.frameRenderingClones(requestDefault);
 
    sliderThreadsLimit->setValue(m_lastUsedThreadsLimit);
    sliderFrameClonesLimit->setValue(m_lastUsedClonesLimit);
 
#if KRITA_QT_HAS_UPDATE_COMPRESSION_PATCH
    m_frameRateModel->data.set(std::make_tuple(cfg.detectFpsLimit(requestDefault), cfg.fpsLimit(requestDefault)));
#else
    m_frameRateModel->data.set(std::make_tuple(false, cfg.fpsLimit(requestDefault)));
    chkDetectFps->setVisible(false);
#endif
    {
        KisConfig cfg2(true);
        chkOpenGLFramerateLogging->setChecked(cfg2.enableOpenGLFramerateLogging(requestDefault));
        chkBrushSpeedLogging->setChecked(cfg2.enableBrushSpeedLogging(requestDefault));
        chkDisableVectorOptimizations->setChecked(cfg2.disableVectorOptimizations(requestDefault));
#ifdef Q_OS_WIN
        chkDisableAVXOptimizations->setChecked(cfg2.disableAVXOptimizations(requestDefault));
#endif
        chkBackgroundCacheGeneration->setChecked(cfg2.calculateAnimationCacheInBackground(requestDefault));
    }
 
    if (cfg.useOnDiskAnimationCacheSwapping(requestDefault)) {
        optOnDisk->setChecked(true);
    } else {
        optInMemory->setChecked(true);
    }
 
    chkCachedFramesSizeLimit->setChecked(cfg.useAnimationCacheFrameSizeLimit(requestDefault));
    intCachedFramesSizeLimit->setValue(cfg.animationCacheFrameSizeLimit(requestDefault));
    intCachedFramesSizeLimit->setEnabled(chkCachedFramesSizeLimit->isChecked());
 
    chkUseRegionOfInterest->setChecked(cfg.useAnimationCacheRegionOfInterest(requestDefault));
    intRegionOfInterestMargin->setValue(cfg.animationCacheRegionOfInterestMargin(requestDefault) * 100.0);
    intRegionOfInterestMargin->setEnabled(chkUseRegionOfInterest->isChecked());
 
    {
        KConfigGroup group = KSharedConfig::openConfig()->group("KisToolTransform");
        chkTransformToolUseInStackPreview->setChecked(!group.readEntry("useOverlayPreviewStyle", false));
        chkTransformToolForceLodMode->setChecked(group.readEntry("forceLodMode", true));
        chkTransformToolForceLodMode->setEnabled(chkTransformToolUseInStackPreview->isChecked());
    }
 
    {
        KConfigGroup group = KSharedConfig::openConfig()->group("KritaTransform/KisToolMove");
        chkMoveToolForceLodMode->setChecked(group.readEntry("forceLodMode", false));
    }
 
    {
        KConfigGroup group( KSharedConfig::openConfig(), "filterdialog");
        chkFiltersForceLodMode->setChecked(group.readEntry("forceLodMode", true));
    }
}

References KisImageConfig::animationCacheFrameSizeLimit(), KisImageConfig::animationCacheRegionOfInterestMargin(), KisConfig::calculateAnimationCacheInBackground(), KisImageConfig::detectFpsLimit(), KisConfig::disableAVXOptimizations(), KisConfig::disableVectorOptimizations(), KisConfig::enableBrushSpeedLogging(), KisConfig::enableOpenGLFramerateLogging(), KisImageConfig::enablePerfLog(), KisImageConfig::enableProgressReporting(), KisImageConfig::fpsLimit(), KisImageConfig::frameRenderingClones(), m_frameRateModel, m_lastUsedClonesLimit, m_lastUsedThreadsLimit, KisImageConfig::maxNumberOfThreads(), KisImageConfig::maxSwapSize(), KisImageConfig::memoryHardLimitPercent(), KisImageConfig::memoryPoolLimitPercent(), KisImageConfig::memorySoftLimitPercent(), KisImageConfig::swapDir(), KisImageConfig::useAnimationCacheFrameSizeLimit(), KisImageConfig::useAnimationCacheRegionOfInterest(), and KisImageConfig::useOnDiskAnimationCacheSwapping().

realTilesRAM()

int PerformanceTab::realTilesRAM ( )

private

Definition at line 1897 of file kis_dlg_preferences.cc.

{
    return intMemoryLimit->value() - intPoolLimit->value();
}

save()

void PerformanceTab::save

(

)

Definition at line 2094 of file kis_dlg_preferences.cc.

{
    KisImageConfig cfg(false);
 
    cfg.setMemoryHardLimitPercent(sliderMemoryLimit->value());
    cfg.setMemorySoftLimitPercent(sliderUndoLimit->value());
    cfg.setMemoryPoolLimitPercent(sliderPoolLimit->value());
 
    cfg.setEnablePerfLog(chkPerformanceLogging->isChecked());
    cfg.setEnableProgressReporting(chkProgressReporting->isChecked());
 
    cfg.setMaxSwapSize(sliderSwapSize->value() * 1024);
 
    cfg.setSwapDir(swapFileLocation->fileName());
 
    cfg.setMaxNumberOfThreads(sliderThreadsLimit->value());
    cfg.setFrameRenderingClones(sliderFrameClonesLimit->value());
    cfg.setFrameRenderingTimeout(sliderFrameTimeout->value() * 1000);
    cfg.setFpsLimit(std::get<int>(*m_frameRateModel->data));
#if KRITA_QT_HAS_UPDATE_COMPRESSION_PATCH
    cfg.setDetectFpsLimit(std::get<bool>(*m_frameRateModel->data));
#endif
 
    {
        KisConfig cfg2(true);
        cfg2.setEnableOpenGLFramerateLogging(chkOpenGLFramerateLogging->isChecked());
        cfg2.setEnableBrushSpeedLogging(chkBrushSpeedLogging->isChecked());
        cfg2.setDisableVectorOptimizations(chkDisableVectorOptimizations->isChecked());
#ifdef Q_OS_WIN
        cfg2.setDisableAVXOptimizations(chkDisableAVXOptimizations->isChecked());
#endif
        cfg2.setCalculateAnimationCacheInBackground(chkBackgroundCacheGeneration->isChecked());
    }
 
    cfg.setUseOnDiskAnimationCacheSwapping(optOnDisk->isChecked());
 
    cfg.setUseAnimationCacheFrameSizeLimit(chkCachedFramesSizeLimit->isChecked());
    cfg.setAnimationCacheFrameSizeLimit(intCachedFramesSizeLimit->value());
 
    cfg.setUseAnimationCacheRegionOfInterest(chkUseRegionOfInterest->isChecked());
    cfg.setAnimationCacheRegionOfInterestMargin(intRegionOfInterestMargin->value() / 100.0);
 
    {
        KConfigGroup group = KSharedConfig::openConfig()->group("KisToolTransform");
        group.writeEntry("useOverlayPreviewStyle", !chkTransformToolUseInStackPreview->isChecked());
        group.writeEntry("forceLodMode", chkTransformToolForceLodMode->isChecked());
    }
 
    {
        KConfigGroup group = KSharedConfig::openConfig()->group("KritaTransform/KisToolMove");
        group.writeEntry("forceLodMode", chkMoveToolForceLodMode->isChecked());
    }
 
    {
        KConfigGroup group( KSharedConfig::openConfig(), "filterdialog");
        group.writeEntry("forceLodMode", chkFiltersForceLodMode->isChecked());
    }
 
}

References m_frameRateModel, KisImageConfig::setAnimationCacheFrameSizeLimit(), KisImageConfig::setAnimationCacheRegionOfInterestMargin(), KisConfig::setCalculateAnimationCacheInBackground(), KisImageConfig::setDetectFpsLimit(), KisConfig::setDisableAVXOptimizations(), KisConfig::setDisableVectorOptimizations(), KisConfig::setEnableBrushSpeedLogging(), KisConfig::setEnableOpenGLFramerateLogging(), KisImageConfig::setEnablePerfLog(), KisImageConfig::setEnableProgressReporting(), KisImageConfig::setFpsLimit(), KisImageConfig::setFrameRenderingClones(), KisImageConfig::setFrameRenderingTimeout(), KisImageConfig::setMaxNumberOfThreads(), KisImageConfig::setMaxSwapSize(), KisImageConfig::setMemoryHardLimitPercent(), KisImageConfig::setMemoryPoolLimitPercent(), KisImageConfig::setMemorySoftLimitPercent(), KisImageConfig::setSwapDir(), KisImageConfig::setUseAnimationCacheFrameSizeLimit(), KisImageConfig::setUseAnimationCacheRegionOfInterest(), and KisImageConfig::setUseOnDiskAnimationCacheSwapping().

slotFrameClonesLimitChanged

void PerformanceTab::slotFrameClonesLimitChanged ( int value )

privateslot

Definition at line 2161 of file kis_dlg_preferences.cc.

{
    KisSignalsBlocker b(sliderThreadsLimit);
    sliderThreadsLimit->setValue(qMax(m_lastUsedThreadsLimit, value));
    m_lastUsedClonesLimit = value;
}

References m_lastUsedClonesLimit, m_lastUsedThreadsLimit, and value().

slotThreadsLimitChanged

void PerformanceTab::slotThreadsLimitChanged ( int value )

privateslot

Definition at line 2154 of file kis_dlg_preferences.cc.

{
    KisSignalsBlocker b(sliderFrameClonesLimit);
    sliderFrameClonesLimit->setValue(qMin(m_lastUsedClonesLimit, value));
    m_lastUsedThreadsLimit = value;
}

References m_lastUsedClonesLimit, m_lastUsedThreadsLimit, and value().

Member Data Documentation

m_frameRateModel

QScopedPointer<KisFrameRateLimitModel> PerformanceTab::m_frameRateModel

private

Definition at line 310 of file kis_dlg_preferences.h.

m_lastUsedClonesLimit

int PerformanceTab::m_lastUsedClonesLimit

private

Definition at line 309 of file kis_dlg_preferences.h.

m_lastUsedThreadsLimit

int PerformanceTab::m_lastUsedThreadsLimit

private

Definition at line 308 of file kis_dlg_preferences.h.

m_syncs

QVector<SliderAndSpinBoxSync*> PerformanceTab::m_syncs

private

Definition at line 307 of file kis_dlg_preferences.h.

---

The documentation for this class was generated from the following files:

• libs/ui/dialogs/kis_dlg_preferences.h
• libs/ui/dialogs/kis_dlg_preferences.cc