feedc0de/qt-creator
1
0
Fork 0
forked from qt-creator/qt-creator
Code Pull Requests Activity

ProgressManager: Use std::chrono for timed tasks

Browse Source 
It is more descriptive than an int.

Change-Id: I129dc931b7dd137846eb97747a5277911b94e06f
Reviewed-by: Jarek Kobus <jaroslaw.kobus@qt.io>
Reviewed-by: Qt CI Bot <qt_ci_bot@qt-project.org>
Reviewed-by: <github-actions-qt-creator@cristianadam.eu>
This commit is contained in:
Eike Ziller
2024-01-19 16:17:01 +01:00
parent 1a84ae038d
commit d53c5344ec
8 changed files with 56 additions and 28 deletions
Download Patch File Download Diff File Expand all files Collapse all files

6
src/plugins/coreplugin/progressmanager/processprogress.cpp
View File

@@ -100,8 +100,10 @@ ProcessProgress::ProcessProgress(Process *process)
if (d->m_parser) {
d->m_futureProgress = ProgressManager::addTask(d->m_futureInterface.future(), name, id);
} else {
d->m_futureProgress = ProgressManager::addTimedTask(d->m_futureInterface, name, id,
d->m_expectedDuration.count());
d->m_futureProgress = ProgressManager::addTimedTask(d->m_futureInterface,
name,
id,
d->m_expectedDuration);
}
d->m_futureProgress->setKeepOnFinish(d->m_keep);
});

34
src/plugins/coreplugin/progressmanager/progressmanager.cpp
View File

@@ -37,7 +37,7 @@
static const char kSettingsGroup[] = "Progress";
static const char kDetailsPinned[] = "DetailsPinned";
static const bool kDetailsPinnedDefault = true;
static const int TimerInterval = 100; // 100 ms
static const std::chrono::milliseconds TimerInterval{100};
using namespace Core::Internal;
using namespace Utils;
@@ -47,10 +47,12 @@ namespace Core {
class ProgressTimer : public QObject
{
public:
ProgressTimer(const QFutureInterfaceBase &futureInterface, int expectedSeconds, QObject *parent)
: QObject(parent),
m_futureInterface(futureInterface),
m_expectedTime(expectedSeconds)
ProgressTimer(const QFutureInterfaceBase &futureInterface,
std::chrono::seconds expectedDuration,
QObject *parent)
: QObject(parent)
, m_futureInterface(futureInterface)
, m_expectedDuration(expectedDuration)
{
m_futureInterface.setProgressRange(0, 100);
m_futureInterface.setProgressValue(0);
@@ -64,13 +66,13 @@ private:
void handleTimeout()
{
++m_currentTime;
const int halfLife = qRound(1000.0 * m_expectedTime / TimerInterval);
const int halfLife = m_expectedDuration / TimerInterval;
const int progress = MathUtils::interpolateTangential(m_currentTime, halfLife, 0, 100);
m_futureInterface.setProgressValue(progress);
}
QFutureInterfaceBase m_futureInterface;
int m_expectedTime;
std::chrono::seconds m_expectedDuration;
int m_currentTime = 0;
QTimer m_timer;
};
@@ -774,22 +776,28 @@ FutureProgress *ProgressManager::addTask(const QFuture<void> &future, const QStr
\sa addTask
*/
FutureProgress *ProgressManager::addTimedTask(const QFutureInterface<void> &futureInterface, const QString &title,
Id type, int expectedSeconds, ProgressFlags flags)
FutureProgress *ProgressManager::addTimedTask(const QFutureInterface<void> &futureInterface,
const QString &title,
Id type,
std::chrono::seconds expectedDuration,
ProgressFlags flags)
{
QFutureInterface<void> dummy(futureInterface); // Need mutable to access .future()
FutureProgress *fp = m_instance->doAddTask(dummy.future(), title, type, flags);
(void) new ProgressTimer(futureInterface, expectedSeconds, fp);
(void) new ProgressTimer(futureInterface, expectedDuration, fp);
return fp;
}
FutureProgress *ProgressManager::addTimedTask(const QFuture<void> &future, const QString &title,
Id type, int expectedSeconds, ProgressFlags flags)
FutureProgress *ProgressManager::addTimedTask(const QFuture<void> &future,
const QString &title,
Id type,
std::chrono::seconds expectedDuration,
ProgressFlags flags)
{
QFutureInterface<void> dummyFutureInterface;
QFuture<void> dummyFuture = dummyFutureInterface.future();
FutureProgress *fp = m_instance->doAddTask(dummyFuture, title, type, flags);
(void) new ProgressTimer(dummyFutureInterface, expectedSeconds, fp);
(void) new ProgressTimer(dummyFutureInterface, expectedDuration, fp);
QFutureWatcher<void> *dummyWatcher = new QFutureWatcher<void>(fp);
connect(dummyWatcher, &QFutureWatcher<void>::canceled, dummyWatcher, [future] {

16
src/plugins/coreplugin/progressmanager/progressmanager.h
View File

@@ -11,6 +11,8 @@
#include <QFutureInterfaceBase>
#include <QObject>
#include <chrono>
namespace Core {
class FutureProgress;
@@ -36,10 +38,16 @@ public:
static FutureProgress *addTask(const QFuture<void> &future, const QString &title,
Utils::Id type, ProgressFlags flags = {});
static FutureProgress *addTimedTask(const QFutureInterface<void> &fi, const QString &title,
Utils::Id type, int expectedSeconds, ProgressFlags flags = {});
static FutureProgress *addTimedTask(const QFuture<void> &future, const QString &title,
Utils::Id type, int expectedSeconds, ProgressFlags flags = {});
static FutureProgress *addTimedTask(const QFutureInterface<void> &fi,
const QString &title,
Utils::Id type,
std::chrono::seconds expectedDuration,
ProgressFlags flags = {});
static FutureProgress *addTimedTask(const QFuture<void> &future,
const QString &title,
Utils::Id type,
std::chrono::seconds expectedDuration,
ProgressFlags flags = {});
static void setApplicationLabel(const QString &text);
public slots:

5
src/plugins/cppeditor/cpptypehierarchy.cpp
View File

@@ -226,8 +226,11 @@ void CppTypeHierarchyWidget::perform()
m_futureWatcher.setFuture(QFuture<void>(m_future));
m_synchronizer.addFuture(m_future);
using namespace std::chrono_literals;
Core::ProgressManager::addTimedTask(m_futureWatcher.future(),
Tr::tr("Evaluating Type Hierarchy"), "TypeHierarchy", 2);
Tr::tr("Evaluating Type Hierarchy"),
"TypeHierarchy",
2s);
}
void CppTypeHierarchyWidget::performFromExpression(const QString &expression, const FilePath &filePath)

8
src/plugins/perfprofiler/perfdatareader.cpp
View File

@@ -188,9 +188,11 @@ void PerfDataReader::triggerRecordingStateChange(bool recording)
qMin(delay(currentTime) / (1000ll * million),
static_cast<qint64>(std::numeric_limits<int>::max())));
Core::FutureProgress *fp = Core::ProgressManager::addTimedTask(
future(), Tr::tr("Skipping Processing Delay"),
Constants::PerfProfilerTaskSkipDelay, seconds);
Core::FutureProgress *fp
= Core::ProgressManager::addTimedTask(future(),
Tr::tr("Skipping Processing Delay"),
Constants::PerfProfilerTaskSkipDelay,
std::chrono::seconds(seconds));
fp->setToolTip(recording ?
Tr::tr("Cancel this to ignore the processing delay and immediately "
"start recording.") :

8
src/plugins/perfprofiler/perfprofilertracemanager.cpp
View File

@@ -605,9 +605,11 @@ void PerfProfilerTraceManager::loadFromPerfData(const FilePath &filePath,
const int fileMegabytes = static_cast<int>(
qMin(filePath.fileSize() >> 20,
static_cast<qint64>(std::numeric_limits<int>::max())));
Core::FutureProgress *fp = Core::ProgressManager::addTimedTask(
reader->future(), Tr::tr("Loading Trace Data"), Constants::PerfProfilerTaskLoadPerf,
fileMegabytes);
Core::FutureProgress *fp
= Core::ProgressManager::addTimedTask(reader->future(),
Tr::tr("Loading Trace Data"),
Constants::PerfProfilerTaskLoadPerf,
std::chrono::seconds(fileMegabytes));
connect(fp, &Core::FutureProgress::canceled, reader, [reader]() {
reader->stopParser();

3
src/plugins/projectexplorer/kitmanager.cpp
View File

@@ -482,10 +482,11 @@ void KitManager::showLoadingProgress()
if (futureInterface.isRunning())
return;
futureInterface.reportStarted();
using namespace std::chrono_literals;
Core::ProgressManager::addTimedTask(futureInterface.future(),
Tr::tr("Loading Kits"),
"LoadingKitsProgress",
5);
5s);
connect(instance(), &KitManager::kitsLoaded, []() { futureInterface.reportFinished(); });
}

4
src/plugins/valgrind/valgrindengine.cpp
View File

@@ -56,7 +56,9 @@ void ValgrindToolRunner::start()
return;
}
FutureProgress *fp = ProgressManager::addTimedTask(m_progress, progressTitle(), "valgrind", 100);
using namespace std::chrono_literals;
FutureProgress *fp
= ProgressManager::addTimedTask(m_progress, progressTitle(), "valgrind", 100s);
connect(fp, &FutureProgress::canceled,
this, &ValgrindToolRunner::handleProgressCanceled);
connect(fp, &FutureProgress::finished,