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

Utils: Move QProcess base to QtcProcessPrivate

Browse Source 
Change-Id: I4c6811d42e051fadfcf32edb664ff3bc09e692e6
Reviewed-by: David Schulz <david.schulz@qt.io>
This commit is contained in:
hjk
2021-05-14 15:21:54 +02:00
parent 0f535703aa
commit 08040e4e94
31 changed files with 399 additions and 218 deletions
Download Patch File Download Diff File Expand all files Collapse all files

20
src/libs/utils/archive.cpp
View File

@@ -212,7 +212,7 @@ Archive *Archive::unarchive(const FilePath &src, const FilePath &dest)
archive->m_process->setProcessChannelMode(QProcess::MergedChannels);
QObject::connect(
archive->m_process,
&QProcess::readyReadStandardOutput,
&QtcProcess::readyReadStandardOutput,
archive,
[archive]() {
if (!archive->m_process)
@@ -222,7 +222,7 @@ Archive *Archive::unarchive(const FilePath &src, const FilePath &dest)
Qt::QueuedConnection);
QObject::connect(
archive->m_process,
QOverload<int, QProcess::ExitStatus>::of(&QProcess::finished),
&QtcProcess::finished,
archive,
[archive](int, QProcess::ExitStatus) {
if (!archive->m_process)
@@ -236,7 +236,7 @@ Archive *Archive::unarchive(const FilePath &src, const FilePath &dest)
Qt::QueuedConnection);
QObject::connect(
archive->m_process,
&QProcess::errorOccurred,
&QtcProcess::errorOccurred,
archive,
[archive](QProcess::ProcessError) {
if (!archive->m_process)
@@ -248,22 +248,18 @@ Archive *Archive::unarchive(const FilePath &src, const FilePath &dest)
archive->deleteLater();
},
Qt::QueuedConnection);
QTimer::singleShot(0, archive, [archive, tool, workingDirectory] {
archive->outputReceived(
tr("Running %1\nin \"%2\".\n\n", "Running <cmd> in <workingdirectory>")
.arg(CommandLine(tool->executable, tool->arguments).toUserOutput(),
workingDirectory));
});
archive->m_process->setProgram(tool->executable);
#ifdef Q_OS_WIN
if (!tool->nativeWindowsArguments)
archive->m_process->setArguments(tool->arguments);
else if (!tool->arguments.isEmpty())
archive->m_process->setNativeArguments(tool->arguments.at(0));
#else
archive->m_process->setArguments(tool->arguments);
#endif
CommandLine cmd = tool->nativeWindowsArguments
? CommandLine{FilePath::fromString(tool->executable), tool->arguments[0], CommandLine::Raw}
: CommandLine{tool->executable, tool->arguments};
archive->m_process->setCommand(cmd);
archive->m_process->setWorkingDirectory(workingDirectory);
archive->m_process->setOpenMode(QProcess::ReadOnly);
archive->m_process->start();

297
src/libs/utils/qtcprocess.cpp
View File

@@ -82,7 +82,7 @@ public:
void clearForRun();
QString linesRead();
void append(const QByteArray &text, bool emitSignals);
void append(const QByteArray &text);
QByteArray rawData;
QString incompleteLineBuffer; // lines not yet signaled
@@ -92,20 +92,88 @@ public:
std::function<void(const QString &lines)> outputCallback;
};
class ProcessHelper : public QProcess
{
public:
ProcessHelper()
{
#if QT_VERSION >= QT_VERSION_CHECK(6, 0, 0) && defined(Q_OS_UNIX)
setChildProcessModifier([this] { d->setupChildProcess_impl(); });
#endif
}
#if QT_VERSION < QT_VERSION_CHECK(6, 0, 0)
void setupChildProcess() override { setupChildProcess_impl(); }
#endif
void setupChildProcess_impl()
{
#if defined Q_OS_UNIX
// nice value range is -20 to +19 where -20 is highest, 0 default and +19 is lowest
if (m_lowPriority) {
errno = 0;
if (::nice(5) == -1 && errno != 0)
perror("Failed to set nice value");
}
// Disable terminal by becoming a session leader.
if (m_disableUnixTerminal)
setsid();
#endif
}
using QProcess::setErrorString;
bool m_lowPriority = false;
bool m_disableUnixTerminal = false;
};
class QtcProcessPrivate : public QObject
{
public:
explicit QtcProcessPrivate(QtcProcess *parent) : q(parent) {}
explicit QtcProcessPrivate(QtcProcess *parent)
: q(parent), m_process(new ProcessHelper)
{
connect(m_process, &QProcess::started,
q, &QtcProcess::started);
connect(m_process, QOverload<int, QProcess::ExitStatus>::of(&QProcess::finished),
q, &QtcProcess::finished);
connect(m_process, &QProcess::errorOccurred,
q, &QtcProcess::errorOccurred);
connect(m_process, &QProcess::stateChanged,
q, &QtcProcess::stateChanged);
connect(m_process, &QProcess::readyReadStandardOutput,
this, &QtcProcessPrivate::handleReadyReadStandardOutput);
connect(m_process, &QProcess::readyReadStandardError,
this, &QtcProcessPrivate::handleReadyReadStandardError);
}
void setupChildProcess_impl();
~QtcProcessPrivate()
{
delete m_process;
}
void handleReadyReadStandardOutput()
{
m_stdOut.append(m_process->readAllStandardOutput());
m_hangTimerCount = 0;
emit q->readyReadStandardOutput();
}
void handleReadyReadStandardError()
{
m_stdErr.append(m_process->readAllStandardError());
m_hangTimerCount = 0;
emit q->readyReadStandardOutput();
}
QtcProcess *q;
ProcessHelper *m_process;
CommandLine m_commandLine;
Environment m_environment;
QByteArray m_writeData;
bool m_haveEnv = false;
bool m_useCtrlCStub = false;
bool m_lowPriority = false;
bool m_disableUnixTerminal = false;
QProcess::OpenMode m_openMode = QProcess::ReadWrite;
@@ -117,7 +185,6 @@ public:
QtcProcess::Result interpretExitCode(int exitCode);
QtcProcess *q;
QTextCodec *m_codec = QTextCodec::codecForLocale();
QTimer m_timer;
QEventLoop m_eventLoop;
@@ -170,16 +237,12 @@ QtcProcess::Result QtcProcessPrivate::interpretExitCode(int exitCode)
*/
QtcProcess::QtcProcess(QObject *parent)
: QProcess(parent), d(new QtcProcessPrivate(this))
: QObject(parent), d(new QtcProcessPrivate(this))
{
static int qProcessExitStatusMeta = qRegisterMetaType<QProcess::ExitStatus>();
static int qProcessProcessErrorMeta = qRegisterMetaType<QProcess::ProcessError>();
Q_UNUSED(qProcessExitStatusMeta)
Q_UNUSED(qProcessProcessErrorMeta)
#if QT_VERSION >= QT_VERSION_CHECK(6, 0, 0) && defined(Q_OS_UNIX)
setChildProcessModifier([this] { d->setupChildProcess_impl(); });
#endif
}
QtcProcess::~QtcProcess()
@@ -208,6 +271,16 @@ const CommandLine &QtcProcess::commandLine() const
return d->m_commandLine;
}
QString QtcProcess::workingDirectory() const
{
return d->m_process->workingDirectory();
}
void QtcProcess::setWorkingDirectory(const QString &dir)
{
d->m_process->setWorkingDirectory(dir);
}
void QtcProcess::setUseCtrlCStub(bool enabled)
{
// Do not use the stub in debug mode. Activating the stub will shut down
@@ -244,7 +317,7 @@ void QtcProcess::start()
qPrintable(d->m_commandLine.executable().toString()));
env = d->m_environment;
QProcess::setProcessEnvironment(env.toProcessEnvironment());
d->m_process->setProcessEnvironment(env.toProcessEnvironment());
} else {
env = Environment::systemEnvironment();
}
@@ -258,25 +331,26 @@ void QtcProcess::start()
if (osType == OsTypeWindows) {
QString args;
if (d->m_useCtrlCStub) {
if (d->m_lowPriority)
if (d->m_process->m_lowPriority)
ProcessArgs::addArg(&args, "-nice");
ProcessArgs::addArg(&args, QDir::toNativeSeparators(command));
command = QCoreApplication::applicationDirPath()
+ QLatin1String("/qtcreator_ctrlc_stub.exe");
} else if (d->m_lowPriority) {
} else if (d->m_process->m_lowPriority) {
#ifdef Q_OS_WIN
setCreateProcessArgumentsModifier([](CreateProcessArguments *args) {
args->flags |= BELOW_NORMAL_PRIORITY_CLASS;
d->m_process->setCreateProcessArgumentsModifier(
[](QProcess::CreateProcessArguments *args) {
args->flags |= BELOW_NORMAL_PRIORITY_CLASS;
});
#endif
}
ProcessArgs::addArgs(&args, arguments.toWindowsArgs());
#ifdef Q_OS_WIN
setNativeArguments(args);
d->m_process->setNativeArguments(args);
#endif
// Note: Arguments set with setNativeArgs will be appended to the ones
// passed with start() below.
QProcess::start(command, QStringList(), d->m_openMode);
d->m_process->start(command, QStringList(), d->m_openMode);
} else {
if (!success) {
setErrorString(tr("Error in command line."));
@@ -285,7 +359,7 @@ void QtcProcess::start()
emit errorOccurred(QProcess::UnknownError);
return;
}
QProcess::start(command, arguments.toUnixArgs(), d->m_openMode);
d->m_process->start(command, arguments.toUnixArgs(), d->m_openMode);
}
}
@@ -321,7 +395,7 @@ void QtcProcess::terminate()
EnumWindows(sendShutDownMessageToAllWindowsOfProcess_enumWnd, processId());
else
#endif
QProcess::terminate();
d->m_process->terminate();
}
void QtcProcess::interrupt()
@@ -334,12 +408,12 @@ void QtcProcess::interrupt()
void QtcProcess::setLowPriority()
{
d->m_lowPriority = true;
d->m_process->m_lowPriority = true;
}
void QtcProcess::setDisableUnixTerminal()
{
d->m_disableUnixTerminal = true;
d->m_process->m_disableUnixTerminal = true;
}
void QtcProcess::setRemoteProcessHooks(const DeviceProcessHooks &hooks)
@@ -347,30 +421,7 @@ void QtcProcess::setRemoteProcessHooks(const DeviceProcessHooks &hooks)
s_deviceHooks = hooks;
}
#if QT_VERSION < QT_VERSION_CHECK(6, 0, 0)
void QtcProcess::setupChildProcess()
{
d->setupChildProcess_impl();
}
#endif
void QtcProcessPrivate::setupChildProcess_impl()
{
#if defined Q_OS_UNIX
// nice value range is -20 to +19 where -20 is highest, 0 default and +19 is lowest
if (m_lowPriority) {
errno = 0;
if (::nice(5) == -1 && errno != 0)
perror("Failed to set nice value");
}
// Disable terminal by becoming a session leader.
if (m_disableUnixTerminal)
setsid();
#endif
}
void QtcProcess::setOpenMode(OpenMode mode)
void QtcProcess::setOpenMode(QIODevice::OpenMode mode)
{
d->m_openMode = mode;
}
@@ -429,7 +480,7 @@ bool QtcProcess::readDataFromProcess(int timeoutS,
return false;
}
QTC_ASSERT(readChannel() == QProcess::StandardOutput, return false);
QTC_ASSERT(d->m_process->readChannel() == QProcess::StandardOutput, return false);
// Keep the process running until it has no longer has data
bool finished = false;
@@ -438,15 +489,15 @@ bool QtcProcess::readDataFromProcess(int timeoutS,
finished = waitForFinished(timeoutS > 0 ? timeoutS * 1000 : -1)
|| state() == QProcess::NotRunning;
// First check 'stdout'
if (bytesAvailable()) { // applies to readChannel() only
if (d->m_process->bytesAvailable()) { // applies to readChannel() only
hasData = true;
const QByteArray newStdOut = readAllStandardOutput();
const QByteArray newStdOut = d->m_process->readAllStandardOutput();
if (stdOut)
stdOut->append(newStdOut);
}
// Check 'stderr' separately. This is a special handling
// for 'git pull' and the like which prints its progress on stderr.
const QByteArray newStdErr = readAllStandardError();
const QByteArray newStdErr = d->m_process->readAllStandardError();
if (!newStdErr.isEmpty()) {
hasData = true;
if (stdErr)
@@ -454,7 +505,7 @@ bool QtcProcess::readDataFromProcess(int timeoutS,
}
// Prompt user, pretend we have data if says 'No'.
const bool hang = !hasData && !finished;
hasData = hang && showTimeOutMessageBox && !askToKill(program());
hasData = hang && showTimeOutMessageBox && !askToKill(d->m_process->program());
} while (hasData && !finished);
if (syncDebug)
qDebug() << "<readDataFromProcess" << finished;
@@ -484,7 +535,7 @@ void QtcProcess::setResult(Result result)
int QtcProcess::exitCode() const
{
return d->m_isSynchronousProcess ? d->m_exitCode : QProcess::exitCode(); // FIXME: Unify.
return d->m_isSynchronousProcess ? d->m_exitCode : d->m_process->exitCode(); // FIXME: Unify.
}
@@ -577,6 +628,115 @@ Environment QtcProcess::systemEnvironmentForBinary(const FilePath &filePath)
return Environment::systemEnvironment();
}
void QtcProcess::setProcessChannelMode(QProcess::ProcessChannelMode mode)
{
d->m_process->setProcessChannelMode(mode);
}
QProcess::ProcessError QtcProcess::error() const
{
return d->m_process->error();
}
QProcess::ProcessState QtcProcess::state() const
{
return d->m_process->state();
}
QString QtcProcess::errorString() const
{
return d->m_process->errorString();
}
void QtcProcess::setErrorString(const QString &str)
{
d->m_process->setErrorString(str);
}
qint64 QtcProcess::processId() const
{
return d->m_process->processId();
}
bool QtcProcess::waitForStarted(int msecs)
{
return d->m_process->waitForStarted(msecs);
}
bool QtcProcess::waitForReadyRead(int msecs)
{
return d->m_process->waitForReadyRead(msecs);
}
bool QtcProcess::waitForFinished(int msecs)
{
return d->m_process->waitForFinished(msecs);
}
QByteArray QtcProcess::readAllStandardOutput()
{
QByteArray buf = d->m_stdOut.rawData;
d->m_stdOut.rawData.clear();
return buf;
}
QByteArray QtcProcess::readAllStandardError()
{
QByteArray buf = d->m_stdErr.rawData;
d->m_stdErr.rawData.clear();
return buf;
}
QByteArray QtcProcess::readAll()
{
return d->m_process->readAll();
}
QByteArray QtcProcess::readLine()
{
return d->m_process->readLine();
}
QProcess::ExitStatus QtcProcess::exitStatus() const
{
return d->m_process->exitStatus();
}
void QtcProcess::kill()
{
d->m_process->kill();
}
qint64 QtcProcess::write(const QByteArray &input)
{
return d->m_process->write(input);
}
void QtcProcess::closeWriteChannel()
{
d->m_process->closeWriteChannel();
}
void QtcProcess::close()
{
d->m_process->close();
}
void QtcProcess::setReadChannel(QProcess::ProcessChannel channel)
{
d->m_process->setReadChannel(channel);
}
bool QtcProcess::canReadLine() const
{
return d->m_process->canReadLine();
}
bool QtcProcess::atEnd() const
{
return d->m_process->atEnd();
}
QString QtcProcess::locateBinary(const QString &binary)
{
const QByteArray path = qgetenv("PATH");
@@ -631,6 +791,11 @@ QString QtcProcess::exitMessage()
return QString();
}
QIODevice *QtcProcess::ioDevice()
{
return d->m_process;
}
QByteArray QtcProcess::allRawOutput() const
{
if (!d->m_stdOut.rawData.isEmpty() && !d->m_stdErr.rawData.isEmpty()) {
@@ -718,13 +883,11 @@ QString ChannelBuffer::linesRead()
return lines;
}
void ChannelBuffer::append(const QByteArray &text, bool emitSignals)
void ChannelBuffer::append(const QByteArray &text)
{
if (text.isEmpty())
return;
rawData += text;
if (!emitSignals)
return;
// Buffered. Emit complete lines?
if (outputCallback) {
@@ -742,17 +905,9 @@ SynchronousProcess::SynchronousProcess()
d->m_timer.setInterval(1000);
connect(&d->m_timer, &QTimer::timeout, d, &QtcProcessPrivate::slotTimeout);
connect(this, QOverload<int, QProcess::ExitStatus>::of(&QProcess::finished),
connect(d->m_process, QOverload<int, QProcess::ExitStatus>::of(&QProcess::finished),
d, &QtcProcessPrivate::slotFinished);
connect(this, &QProcess::errorOccurred, d, &QtcProcessPrivate::slotError);
connect(this, &QProcess::readyReadStandardOutput, d, [this] {
d->m_hangTimerCount = 0;
d->m_stdOut.append(readAllStandardOutput(), true);
});
connect(this, &QProcess::readyReadStandardError, d, [this] {
d->m_hangTimerCount = 0;
d->m_stdErr.append(readAllStandardError(), true);
});
connect(d->m_process, &QProcess::errorOccurred, d, &QtcProcessPrivate::slotError);
}
SynchronousProcess::~SynchronousProcess()
@@ -818,8 +973,6 @@ void SynchronousProcess::runBlocking()
d->m_result = QtcProcess::Finished;
d->m_exitCode = exitCode();
d->m_stdOut.rawData += readAllStandardOutput();
d->m_stdErr.rawData += readAllStandardError();
return;
};
@@ -833,7 +986,7 @@ void SynchronousProcess::runBlocking()
if (d->m_processUserEvents) {
if (!d->m_writeData.isEmpty()) {
connect(this, &QProcess::started, this, [this] {
connect(d->m_process, &QProcess::started, this, [this] {
write(d->m_writeData);
closeWriteChannel();
});
@@ -851,8 +1004,8 @@ void SynchronousProcess::runBlocking()
QApplication::setOverrideCursor(Qt::WaitCursor);
#endif
d->m_eventLoop.exec(QEventLoop::ExcludeUserInputEvents);
d->m_stdOut.append(readAllStandardOutput(), false);
d->m_stdErr.append(readAllStandardError(), false);
d->m_stdOut.append(d->m_process->readAllStandardOutput());
d->m_stdErr.append(d->m_process->readAllStandardError());
d->m_timer.stop();
#ifdef QT_GUI_LIB
@@ -887,8 +1040,8 @@ void SynchronousProcess::runBlocking()
else
d->m_result = d->interpretExitCode(d->m_exitCode);
}
d->m_stdOut.append(readAllStandardOutput(), false);
d->m_stdErr.append(readAllStandardError(), false);
d->m_stdOut.append(d->m_process->readAllStandardOutput());
d->m_stdErr.append(d->m_process->readAllStandardError());
}
}

55
src/libs/utils/qtcprocess.h
View File

@@ -52,7 +52,7 @@ public:
std::function<Environment(const FilePath &)> systemEnvironmentForBinary;
};
class QTCREATOR_UTILS_EXPORT QtcProcess : public QProcess
class QTCREATOR_UTILS_EXPORT QtcProcess : public QObject
{
Q_OBJECT
@@ -78,6 +78,9 @@ public:
void setCommand(const CommandLine &cmdLine);
const CommandLine &commandLine() const;
QString workingDirectory() const;
void setWorkingDirectory(const QString &dir);
void setUseCtrlCStub(bool enabled);
void setLowPriority();
void setDisableUnixTerminal();
@@ -103,7 +106,7 @@ public:
static void setRemoteProcessHooks(const DeviceProcessHooks &hooks);
void setOpenMode(OpenMode mode);
void setOpenMode(QIODevice::OpenMode mode);
bool stopProcess();
bool readDataFromProcess(int timeoutS, QByteArray *stdOut, QByteArray *stdErr,
@@ -134,10 +137,52 @@ public:
static Environment systemEnvironmentForBinary(const FilePath &filePath);
// FIXME: Cut down the following bits inherited from QProcess and QIODevice.
void setProcessChannelMode(QProcess::ProcessChannelMode mode);
QProcess::ProcessError error() const;
QProcess::ProcessState state() const;
QString errorString() const;
void setErrorString(const QString &str);
qint64 processId() const;
bool waitForStarted(int msecs = 30000);
bool waitForReadyRead(int msecs = 30000);
bool waitForFinished(int msecs = 30000);
QByteArray readAllStandardOutput();
QByteArray readAllStandardError();
QByteArray readAll();
QByteArray readLine();
QProcess::ExitStatus exitStatus() const;
void kill();
qint64 write(const QByteArray &input);
void closeWriteChannel();
void close();
void setReadChannel(QProcess::ProcessChannel channel);
bool canReadLine() const;
bool atEnd() const;
QIODevice *ioDevice(); // FIXME: Remove.
signals:
void started();
void finished(int exitCode, QProcess::ExitStatus exitStatus);
void errorOccurred(QProcess::ProcessError error);
void stateChanged(QProcess::ProcessState state);
void readyReadStandardOutput();
void readyReadStandardError();
void readyRead();
private:
#if QT_VERSION < QT_VERSION_CHECK(6, 0, 0)
void setupChildProcess() override;
#endif
friend class SynchronousProcess;
friend QTCREATOR_UTILS_EXPORT QDebug operator<<(QDebug str, const QtcProcess &r);

2
src/plugins/android/androidsdkmanager.cpp
View File

@@ -1086,7 +1086,7 @@ void AndroidSdkManagerPrivate::getPendingLicense(SdkCmdFutureInterface &fi)
}
m_licenseTextCache.clear();
result.success = licenseCommand.exitStatus() == QtcProcess::NormalExit;
result.success = licenseCommand.exitStatus() == QProcess::NormalExit;
if (!result.success) {
result.stdError = QCoreApplication::translate("Android::Internal::AndroidSdkManager",
"License command failed.\n\n");

5
src/plugins/android/androidsettingswidget.cpp
View File

@@ -730,8 +730,7 @@ void AndroidSettingsWidget::downloadOpenSslRepo(const bool silent)
openButton->deleteLater();
};
connect(gitCloner,
QOverload<int, QtcProcess::ExitStatus>::of(&QtcProcess::finished),
connect(gitCloner, &QtcProcess::finished,
m_ui.openSslPathChooser,
[=](int exitCode, QProcess::ExitStatus exitStatus) {
openSslProgressDialog->close();
@@ -739,7 +738,7 @@ void AndroidSettingsWidget::downloadOpenSslRepo(const bool silent)
m_ui.openSslPathChooser->triggerChanged(); // After cloning, the path exists
if (!openSslProgressDialog->wasCanceled()
|| (exitStatus == QtcProcess::NormalExit && exitCode != 0)) {
|| (exitStatus == QProcess::NormalExit && exitCode != 0)) {
failDialog();
}
});

27
src/plugins/baremetal/debugservers/uvsc/uvscserverprovider.cpp
View File

@@ -380,31 +380,22 @@ UvscServerProviderRunner::UvscServerProviderRunner(ProjectExplorer::RunControl *
{
setId("BareMetalUvscServer");
const QString program = runnable.executable.toString();
const QStringList args = runnable.commandLineArguments.split(' ');
m_process.setProgram(program);
m_process.setArguments(args);
m_process.setCommand(runnable.commandLine());
connect(&m_process, &QtcProcess::started, this, [this]() {
connect(&m_process, &QtcProcess::started, this, [this] {
ProcessHandle pid(m_process.processId());
this->runControl()->setApplicationProcessHandle(pid);
reportStarted();
});
connect(&m_process,
QOverload<int, QProcess::ExitStatus>::of(&QtcProcess::finished),
this,
[this](int exitCode, QProcess::ExitStatus status) {
const QString msg = (status == QProcess::CrashExit)
? RunControl::tr("%1 crashed.")
: RunControl::tr("%2 exited with code %1").arg(exitCode);
appendMessage(msg.arg(m_process.program()), Utils::NormalMessageFormat);
reportStopped();
});
connect(&m_process, &QtcProcess::finished, this, [this] {
appendMessage(m_process.exitMessage(), NormalMessageFormat);
reportStopped();
});
connect(&m_process, &QtcProcess::errorOccurred, this, [this] (QProcess::ProcessError error) {
if (error == QProcess::Timedout)
return; // No actual change on the process side.
const QString msg = userMessageForProcessError(
error, FilePath::fromString(m_process.program()));
error, m_process.commandLine().executable());
appendMessage(msg, Utils::NormalMessageFormat);
reportStopped();
});
@@ -412,8 +403,8 @@ UvscServerProviderRunner::UvscServerProviderRunner(ProjectExplorer::RunControl *
void UvscServerProviderRunner::start()
{
const QString msg = RunControl::tr("Starting %1 %2...")
.arg(m_process.program()).arg(m_process.arguments().join(' '));
const QString msg = RunControl::tr("Starting %1 ...")
.arg(m_process.commandLine().toUserOutput());
appendMessage(msg, Utils::NormalMessageFormat);
m_process.start();

4
src/plugins/baremetal/debugservers/uvsc/uvscserverprovider.h
View File

@@ -32,6 +32,8 @@
#include <projectexplorer/runcontrol.h> // for RunWorker
#include <utils/qtcprocess.h>
namespace Utils { class PathChooser; }
namespace BareMetal {
@@ -149,7 +151,7 @@ private:
void start() final;
void stop() final;
QProcess m_process;
Utils::QtcProcess m_process;
};
} // namespace Internal

8
src/plugins/clangtools/clangtoolrunner.cpp
View File

@@ -83,13 +83,11 @@ void ClangToolRunner::init(const QString &outputDirPath, const Environment &envi
m_outputDirPath = outputDirPath;
QTC_CHECK(!m_outputDirPath.isEmpty());
m_process->setProcessChannelMode(QProcess::MergedChannels);
m_process->setEnvironment(environment);
m_process->setWorkingDirectory(m_outputDirPath); // Current clang-cl puts log file into working dir.
connect(m_process, QOverload<int, QProcess::ExitStatus>::of(&QProcess::finished),
this, &ClangToolRunner::onProcessFinished);
connect(m_process, &QProcess::errorOccurred, this, &ClangToolRunner::onProcessError);
connect(m_process, &QProcess::readyRead, this, &ClangToolRunner::onProcessOutput);
connect(m_process, &QtcProcess::finished, this, &ClangToolRunner::onProcessFinished);
connect(m_process, &QtcProcess::errorOccurred, this, &ClangToolRunner::onProcessError);
connect(m_process, &QtcProcess::readyRead, this, &ClangToolRunner::onProcessOutput);
}
QStringList ClangToolRunner::mainToolArguments() const

8
src/plugins/cmakeprojectmanager/cmakeprocess.cpp
View File

@@ -35,6 +35,8 @@
#include <utils/stringutils.h>
using namespace Utils;
namespace CMakeProjectManager {
namespace Internal {
@@ -104,11 +106,11 @@ void CMakeProcess::run(const BuildDirParameters &parameters, const QStringList &
process->setWorkingDirectory(workDirectory.toString());
process->setEnvironment(parameters.environment);
connect(process.get(), &QProcess::readyReadStandardOutput,
connect(process.get(), &QtcProcess::readyReadStandardOutput,
this, &CMakeProcess::processStandardOutput);
connect(process.get(), &QProcess::readyReadStandardError,
connect(process.get(), &QtcProcess::readyReadStandardError,
this, &CMakeProcess::processStandardError);
connect(process.get(), QOverload<int, QProcess::ExitStatus>::of(&QProcess::finished),
connect(process.get(), &QtcProcess::finished,
this, &CMakeProcess::handleProcessFinished);
Utils::CommandLine commandLine(cmake->cmakeExecutable(), QStringList({"-S", srcDir, QString("-B"), workDirectory.toString()}) + arguments);

11
src/plugins/coreplugin/externaltool.cpp
View File

@@ -653,13 +653,12 @@ void ExternalToolRunner::run()
}
}
m_process = new QtcProcess(this);
connect(m_process, &QProcess::started, this, &ExternalToolRunner::started);
connect(m_process, QOverload<int, QProcess::ExitStatus>::of(&QProcess::finished),
this, &ExternalToolRunner::finished);
connect(m_process, &QProcess::errorOccurred, this, &ExternalToolRunner::error);
connect(m_process, &QProcess::readyReadStandardOutput,
connect(m_process, &QtcProcess::started, this, &ExternalToolRunner::started);
connect(m_process, &QtcProcess::finished, this, &ExternalToolRunner::finished);
connect(m_process, &QtcProcess::errorOccurred, this, &ExternalToolRunner::error);
connect(m_process, &QtcProcess::readyReadStandardOutput,
this, &ExternalToolRunner::readStandardOutput);
connect(m_process, &QProcess::readyReadStandardError,
connect(m_process, &QtcProcess::readyReadStandardError,
this, &ExternalToolRunner::readStandardError);
if (!m_resolvedWorkingDirectory.isEmpty())
m_process->setWorkingDirectory(m_resolvedWorkingDirectory);

9
src/plugins/coreplugin/locator/executefilter.cpp
View File

@@ -34,6 +34,8 @@
using namespace Core;
using namespace Core::Internal;
using namespace Utils;
ExecuteFilter::ExecuteFilter()
{
setId("Execute custom commands");
@@ -47,10 +49,9 @@ ExecuteFilter::ExecuteFilter()
m_process = new Utils::QtcProcess(this);
m_process->setEnvironment(Utils::Environment::systemEnvironment());
connect(m_process, QOverload<int ,QProcess::ExitStatus>::of(&QProcess::finished),
this, &ExecuteFilter::finished);
connect(m_process, &QProcess::readyReadStandardOutput, this, &ExecuteFilter::readStandardOutput);
connect(m_process, &QProcess::readyReadStandardError, this, &ExecuteFilter::readStandardError);
connect(m_process, &QtcProcess::finished, this, &ExecuteFilter::finished);
connect(m_process, &QtcProcess::readyReadStandardOutput, this, &ExecuteFilter::readStandardOutput);
connect(m_process, &QtcProcess::readyReadStandardError, this, &ExecuteFilter::readStandardError);
m_runTimer.setSingleShot(true);
connect(&m_runTimer, &QTimer::timeout, this, &ExecuteFilter::runHeadCommand);

8
src/plugins/coreplugin/locator/spotlightlocatorfilter.cpp
View File

@@ -92,16 +92,14 @@ SpotlightIterator::SpotlightIterator(const QStringList &command)
m_process->setCommand({Environment::systemEnvironment().searchInPath(command.first()),
command.mid(1)});
m_process->setEnvironment(Utils::Environment::systemEnvironment());
QObject::connect(m_process.get(),
QOverload<int, QProcess::ExitStatus>::of(&QProcess::finished),
[this] { scheduleKillProcess(); });
QObject::connect(m_process.get(), &QProcess::errorOccurred, [this, command] {
QObject::connect(m_process.get(), &QtcProcess::finished, [this] { scheduleKillProcess(); });
QObject::connect(m_process.get(), &QtcProcess::errorOccurred, [this, command] {
MessageManager::writeFlashing(
SpotlightLocatorFilter::tr("Locator: Error occurred when running \"%1\".")
.arg(command.first()));
scheduleKillProcess();
});
QObject::connect(m_process.get(), &QProcess::readyReadStandardOutput, [this] {
QObject::connect(m_process.get(), &QtcProcess::readyReadStandardOutput, [this] {
QString output = QString::fromUtf8(m_process->readAllStandardOutput());
output.replace("\r\n", "\n");
const QStringList items = output.split('\n');

3
src/plugins/coreplugin/patchtool.cpp
View File

@@ -112,8 +112,11 @@ static bool runPatchHelper(const QByteArray &input, const QString &workingDirect
.arg(patch, patchProcess.errorString()));
return false;
}
patchProcess.write(input);
patchProcess.closeWriteChannel();
QByteArray stdOut;
QByteArray stdErr;
if (!patchProcess.readDataFromProcess(30, &stdOut, &stdErr, true)) {

11
src/plugins/cppcheck/cppcheckrunner.cpp
View File

@@ -49,13 +49,13 @@ CppcheckRunner::CppcheckRunner(CppcheckTool &tool) :
m_maxArgumentsLength = std::max(argMax.toInt(), m_maxArgumentsLength);
}
connect(m_process, &QProcess::readyReadStandardOutput,
connect(m_process, &QtcProcess::readyReadStandardOutput,
this, &CppcheckRunner::readOutput);
connect(m_process, &QProcess::readyReadStandardOutput,
connect(m_process, &QtcProcess::readyReadStandardOutput,
this, &CppcheckRunner::readError);
connect(m_process, &QProcess::started,
connect(m_process, &QtcProcess::started,
this, &CppcheckRunner::handleStarted);
connect(m_process, QOverload<int, QProcess::ExitStatus>::of(&QProcess::finished),
connect(m_process, &QtcProcess::finished,
this, &CppcheckRunner::handleFinished);
m_queueTimer.setSingleShot(true);
@@ -128,8 +128,7 @@ const Utils::FilePaths &CppcheckRunner::currentFiles() const
QString CppcheckRunner::currentCommand() const
{
return m_process->program() + ' ' +
m_process->arguments().join(' ');
return m_process->commandLine().toUserOutput();
}
void CppcheckRunner::checkQueued()

9
src/plugins/debugger/cdb/cdbengine.cpp
View File

@@ -205,12 +205,11 @@ CdbEngine::CdbEngine() :
DebuggerSettings *s = debuggerSettings();
connect(s->createFullBacktrace.action(), &QAction::triggered,
this, &CdbEngine::createFullBacktrace);
connect(&m_process, QOverload<int, QProcess::ExitStatus>::of(&QProcess::finished),
this, &CdbEngine::processFinished);
connect(&m_process, &QProcess::errorOccurred, this, &CdbEngine::processError);
connect(&m_process, &QProcess::readyReadStandardOutput,
connect(&m_process, &QtcProcess::finished, this, &CdbEngine::processFinished);
connect(&m_process, &QtcProcess::errorOccurred, this, &CdbEngine::processError);
connect(&m_process, &QtcProcess::readyReadStandardOutput,
this, &CdbEngine::readyReadStandardOut);
connect(&m_process, &QProcess::readyReadStandardError,
connect(&m_process, &QtcProcess::readyReadStandardError,
this, &CdbEngine::readyReadStandardOut);
connect(&s->useDebuggingHelpers, &BaseAspect::changed,
this, &CdbEngine::updateLocals);

8
src/plugins/debugger/debuggerruncontrol.cpp
View File

@@ -103,13 +103,13 @@ public:
LocalProcessRunner(DebuggerRunTool *runTool, const CommandLine &command)
: RunWorker(runTool->runControl()), m_runTool(runTool), m_command(command)
{
connect(&m_proc, &QProcess::errorOccurred,
connect(&m_proc, &QtcProcess::errorOccurred,
this, &LocalProcessRunner::handleError);
connect(&m_proc, &QProcess::readyReadStandardOutput,
connect(&m_proc, &QtcProcess::readyReadStandardOutput,
this, &LocalProcessRunner::handleStandardOutput);
connect(&m_proc, &QProcess::readyReadStandardError,
connect(&m_proc, &QtcProcess::readyReadStandardError,
this, &LocalProcessRunner::handleStandardError);
connect(&m_proc, QOverload<int, QProcess::ExitStatus>::of(&QProcess::finished),
connect(&m_proc, &QtcProcess::finished,
this, &LocalProcessRunner::handleFinished);
}

4
src/plugins/debugger/gdb/gdbengine.cpp
View File

@@ -166,9 +166,9 @@ GdbEngine::GdbEngine()
connect(&s.useDynamicType, &BaseAspect::changed,
this, &GdbEngine::reloadLocals);
connect(&m_gdbProc, &QProcess::errorOccurred,
connect(&m_gdbProc, &QtcProcess::errorOccurred,
this, &GdbEngine::handleGdbError);
connect(&m_gdbProc, QOverload<int, QProcess::ExitStatus>::of(&QProcess::finished),
connect(&m_gdbProc, &QtcProcess::finished,
this, &GdbEngine::handleGdbFinished);
connect(&m_gdbProc, &QtcProcess::readyReadStandardOutput,
this, &GdbEngine::readGdbStandardOutput);

8
src/plugins/debugger/lldb/lldbengine.cpp
View File

@@ -98,13 +98,13 @@ LldbEngine::LldbEngine()
connect(&ds.intelFlavor, &BaseAspect::changed,
this, &LldbEngine::updateAll);
connect(&m_lldbProc, &QProcess::errorOccurred,
connect(&m_lldbProc, &QtcProcess::errorOccurred,
this, &LldbEngine::handleLldbError);
connect(&m_lldbProc, QOverload<int, QProcess::ExitStatus>::of(&QProcess::finished),
connect(&m_lldbProc, &QtcProcess::finished,
this, &LldbEngine::handleLldbFinished);
connect(&m_lldbProc, &QProcess::readyReadStandardOutput,
connect(&m_lldbProc, &QtcProcess::readyReadStandardOutput,
this, &LldbEngine::readLldbStandardOutput);
connect(&m_lldbProc, &QProcess::readyReadStandardError,
connect(&m_lldbProc, &QtcProcess::readyReadStandardError,
this, &LldbEngine::readLldbStandardError);
connect(this, &LldbEngine::outputReady,

11
src/plugins/docker/dockerdevice.cpp
View File

@@ -129,14 +129,13 @@ void DockerDeviceProcess::start(const Runnable &runnable)
m_process.setCommand(runnable.commandLine());
m_process.setEnvironment(runnable.environment);
m_process.setWorkingDirectory(runnable.workingDirectory);
connect(&m_process, &QProcess::errorOccurred, this, &DeviceProcess::error);
connect(&m_process, QOverload<int, QProcess::ExitStatus>::of(&QProcess::finished),
this, &DeviceProcess::finished);
connect(&m_process, &QProcess::readyReadStandardOutput,
connect(&m_process, &QtcProcess::errorOccurred, this, &DeviceProcess::error);
connect(&m_process, &QtcProcess::finished, this, &DeviceProcess::finished);
connect(&m_process, &QtcProcess::readyReadStandardOutput,
this, &DeviceProcess::readyReadStandardOutput);
connect(&m_process, &QProcess::readyReadStandardError,
connect(&m_process, &QtcProcess::readyReadStandardError,
this, &DeviceProcess::readyReadStandardError);
connect(&m_process, &QProcess::started, this, &DeviceProcess::started);
connect(&m_process, &QtcProcess::started, this, &DeviceProcess::started);
dockerDevice->runProcess(m_process);
}

3
src/plugins/docker/dockersettings.cpp
View File

@@ -83,8 +83,7 @@ void DockerSettings::updateImageList()
QtcProcess process;
process.setCommand({"docker", {"search", imageListFilter.value()}});
const auto finished = QOverload<int, QProcess::ExitStatus>::of(&QProcess::finished);
connect(&process, finished, this, [&process, this] {
connect(&process, &QtcProcess::finished, this, [&process, this] {
const QString data = QString::fromUtf8(process.readAll());
imageList.setValue(data);
});

13
src/plugins/git/gerrit/gerritmodel.cpp
View File

@@ -52,6 +52,7 @@
enum { debug = 0 };
using namespace Utils;
using namespace VcsBase;
namespace Gerrit {
@@ -283,17 +284,16 @@ QueryContext::QueryContext(const QString &query,
+ "&o=CURRENT_REVISION&o=DETAILED_LABELS&o=DETAILED_ACCOUNTS";
m_arguments = server.curlArguments() << url;
}
connect(&m_process, &QProcess::readyReadStandardError, this, [this] {
connect(&m_process, &QtcProcess::readyReadStandardError, this, [this] {
const QString text = QString::fromLocal8Bit(m_process.readAllStandardError());
VcsOutputWindow::appendError(text);
m_error.append(text);
});
connect(&m_process, &QProcess::readyReadStandardOutput, this, [this] {
connect(&m_process, &QtcProcess::readyReadStandardOutput, this, [this] {
m_output.append(m_process.readAllStandardOutput());
});
connect(&m_process, QOverload<int, QProcess::ExitStatus>::of(&QProcess::finished),
this, &QueryContext::processFinished);
connect(&m_process, &QProcess::errorOccurred, this, &QueryContext::processError);
connect(&m_process, &QtcProcess::finished, this, &QueryContext::processFinished);
connect(&m_process, &QtcProcess::errorOccurred, this, &QueryContext::processError);
connect(&m_watcher, &QFutureWatcherBase::canceled, this, &QueryContext::terminate);
m_watcher.setFuture(m_progress.future());
m_process.setEnvironment(Git::Internal::GitClient::instance()->processEnvironment());
@@ -383,8 +383,7 @@ void QueryContext::timeout()
arg(timeOutMS / 1000), QMessageBox::NoButton, parent);
QPushButton *terminateButton = box.addButton(tr("Terminate"), QMessageBox::YesRole);
box.addButton(tr("Keep Running"), QMessageBox::NoRole);
connect(&m_process, QOverload<int, QProcess::ExitStatus>::of(&QProcess::finished),
&box, &QDialog::reject);
connect(&m_process, &QtcProcess::finished, &box, &QDialog::reject);
box.exec();
if (m_process.state() != QProcess::Running)
return;

9
src/plugins/git/gerrit/gerritplugin.cpp
View File

@@ -140,12 +140,11 @@ FetchContext::FetchContext(const QSharedPointer<GerritChange> &change,
, m_server(server)
, m_state(FetchState)
{
connect(&m_process, &QProcess::errorOccurred, this, &FetchContext::processError);
connect(&m_process, QOverload<int, QProcess::ExitStatus>::of(&QProcess::finished),
this, &FetchContext::processFinished);
connect(&m_process, &QProcess::readyReadStandardError,
connect(&m_process, &QtcProcess::errorOccurred, this, &FetchContext::processError);
connect(&m_process, &QtcProcess::finished, this, &FetchContext::processFinished);
connect(&m_process, &QtcProcess::readyReadStandardError,
this, &FetchContext::processReadyReadStandardError);
connect(&m_process, &QProcess::readyReadStandardOutput,
connect(&m_process, &QtcProcess::readyReadStandardOutput,
this, &FetchContext::processReadyReadStandardOutput);
connect(&m_watcher, &QFutureWatcher<void>::canceled, this, &FetchContext::terminate);
m_watcher.setFuture(m_progress.future());

10
src/plugins/languageclient/languageclientinterface.cpp
View File

@@ -30,6 +30,7 @@
#include <QLoggingCategory>
using namespace LanguageServerProtocol;
using namespace Utils;
static Q_LOGGING_CATEGORY(LOGLSPCLIENTV, "qtc.languageclient.messages", QtWarningMsg);
@@ -88,11 +89,11 @@ void BaseClientInterface::parseData(const QByteArray &data)
StdIOClientInterface::StdIOClientInterface()
{
connect(&m_process, &QProcess::readyReadStandardError,
connect(&m_process, &QtcProcess::readyReadStandardError,
this, &StdIOClientInterface::readError);
connect(&m_process, &QProcess::readyReadStandardOutput,
connect(&m_process, &QtcProcess::readyReadStandardOutput,
this, &StdIOClientInterface::readOutput);
connect(&m_process, QOverload<int, QProcess::ExitStatus>::of(&QProcess::finished),
connect(&m_process, &QtcProcess::finished,
this, &StdIOClientInterface::onProcessFinished);
}
@@ -124,7 +125,8 @@ void StdIOClientInterface::setWorkingDirectory(const QString &workingDirectory)
void StdIOClientInterface::sendData(const QByteArray &data)
{
if (m_process.state() != QProcess::Running) {
emit error(tr("Cannot send data to unstarted server %1").arg(m_process.program()));
emit error(tr("Cannot send data to unstarted server %1")
.arg(m_process.commandLine().toUserOutput()));
return;
}
qCDebug(LOGLSPCLIENTV) << "StdIOClient send data:";

13
src/plugins/mesonprojectmanager/project/mesonprocess.cpp
View File

@@ -37,6 +37,8 @@
#include <QLoggingCategory>
using namespace Utils;
namespace MesonProjectManager {
namespace Internal {
@@ -164,19 +166,16 @@ void MesonProcess::setupProcess(const Command &command,
if (m_process)
disconnect(m_process.get());
m_process = std::make_unique<Utils::QtcProcess>();
connect(m_process.get(),
QOverload<int, QProcess::ExitStatus>::of(&QProcess::finished),
this,
&MesonProcess::handleProcessFinished);
connect(m_process.get(), &QProcess::errorOccurred, this, &MesonProcess::handleProcessError);
connect(m_process.get(), &QtcProcess::finished, this, &MesonProcess::handleProcessFinished);
connect(m_process.get(), &QtcProcess::errorOccurred, this, &MesonProcess::handleProcessError);
if (!captureStdo) {
connect(m_process.get(),
&QProcess::readyReadStandardOutput,
&QtcProcess::readyReadStandardOutput,
this,
&MesonProcess::processStandardOutput);
connect(m_process.get(),
&QProcess::readyReadStandardError,
&QtcProcess::readyReadStandardError,
this,
&MesonProcess::processStandardError);
}

7
src/plugins/perforce/perforcechecker.cpp
View File

@@ -34,14 +34,15 @@
#include <QRegularExpression>
#include <QTimer>
using namespace Utils;
namespace Perforce {
namespace Internal {
PerforceChecker::PerforceChecker(QObject *parent) : QObject(parent)
{
connect(&m_process, &QProcess::errorOccurred, this, &PerforceChecker::slotError);
connect(&m_process, QOverload<int, QProcess::ExitStatus>::of(&QProcess::finished),
this, &PerforceChecker::slotFinished);
connect(&m_process, &QtcProcess::errorOccurred, this, &PerforceChecker::slotError);
connect(&m_process, &QtcProcess::finished, this, &PerforceChecker::slotFinished);
}
PerforceChecker::~PerforceChecker()

14
src/plugins/projectexplorer/abstractprocessstep.cpp
View File

@@ -99,7 +99,7 @@ class AbstractProcessStep::Private
public:
Private(AbstractProcessStep *q) : q(q) {}
void cleanUp(QProcess *process);
void cleanUp(QtcProcess *process);
AbstractProcessStep *q;
std::unique_ptr<QtcProcess> m_process;
@@ -232,11 +232,11 @@ void AbstractProcessStep::doRun()
if (d->m_lowPriority && ProjectExplorerPlugin::projectExplorerSettings().lowBuildPriority)
d->m_process->setLowPriority();
connect(d->m_process.get(), &QProcess::readyReadStandardOutput,
connect(d->m_process.get(), &QtcProcess::readyReadStandardOutput,
this, &AbstractProcessStep::processReadyReadStdOutput);
connect(d->m_process.get(), &QProcess::readyReadStandardError,
connect(d->m_process.get(), &QtcProcess::readyReadStandardError,
this, &AbstractProcessStep::processReadyReadStdError);
connect(d->m_process.get(), QOverload<int, QProcess::ExitStatus>::of(&QProcess::finished),
connect(d->m_process.get(), &QtcProcess::finished,
this, &AbstractProcessStep::slotProcessFinished);
d->m_process->start();
@@ -282,7 +282,7 @@ void AbstractProcessStep::setupProcessParameters(ProcessParameters *params) cons
params->setCommandLine(d->m_commandLineProvider());
}
void AbstractProcessStep::Private::cleanUp(QProcess *process)
void AbstractProcessStep::Private::cleanUp(QtcProcess *process)
{
// The process has finished, leftover data is read in processFinished
q->processFinished(process->exitCode(), process->exitStatus());
@@ -400,9 +400,9 @@ void AbstractProcessStep::finish(bool success)
void AbstractProcessStep::slotProcessFinished(int, QProcess::ExitStatus)
{
QProcess *process = d->m_process.get();
QtcProcess *process = d->m_process.get();
if (!process) // Happens when the process was canceled and handed over to the Reaper.
process = qobject_cast<QProcess *>(sender()); // The process was canceled!
process = qobject_cast<QtcProcess *>(sender()); // The process was canceled!
if (process) {
stdError(d->stderrStream->toUnicode(process->readAllStandardError()));
stdOutput(d->stdoutStream->toUnicode(process->readAllStandardOutput()));

12
src/plugins/projectexplorer/applicationlauncher.cpp
View File

@@ -131,18 +131,18 @@ ApplicationLauncherPrivate::ApplicationLauncherPrivate(ApplicationLauncher *pare
m_guiProcess.setProcessChannelMode(QProcess::MergedChannels);
} else {
m_guiProcess.setProcessChannelMode(QProcess::SeparateChannels);
connect(&m_guiProcess, &QProcess::readyReadStandardError,
connect(&m_guiProcess, &QtcProcess::readyReadStandardError,
this, &ApplicationLauncherPrivate::readLocalStandardError);
}
connect(&m_guiProcess, &QProcess::readyReadStandardOutput,
connect(&m_guiProcess, &QtcProcess::readyReadStandardOutput,
this, &ApplicationLauncherPrivate::readLocalStandardOutput);
connect(&m_guiProcess, &QProcess::errorOccurred,
connect(&m_guiProcess, &QtcProcess::errorOccurred,
this, &ApplicationLauncherPrivate::localGuiProcessError);
connect(&m_guiProcess, QOverload<int, QProcess::ExitStatus>::of(&QProcess::finished),
connect(&m_guiProcess, &QtcProcess::finished,
this, &ApplicationLauncherPrivate::localProcessDone);
connect(&m_guiProcess, &QProcess::started,
connect(&m_guiProcess, &QtcProcess::started,
this, &ApplicationLauncherPrivate::handleProcessStarted);
connect(&m_guiProcess, &QProcess::errorOccurred,
connect(&m_guiProcess, &QtcProcess::errorOccurred,
q, &ApplicationLauncher::error);
m_consoleProcess.setSettings(Core::ICore::settings());

10
src/plugins/python/pythonutils.cpp
View File

@@ -251,15 +251,15 @@ public:
{
Core::ProgressManager::addTask(m_future.future(), "Install PyLS", installPylsTaskId);
connect(&m_process,
QOverload<int, QProcess::ExitStatus>::of(&QProcess::finished),
&QtcProcess::finished,
this,
&PythonLSInstallHelper::installFinished);
connect(&m_process,
&QProcess::readyReadStandardError,
&QtcProcess::readyReadStandardError,
this,
&PythonLSInstallHelper::errorAvailable);
connect(&m_process,
&QProcess::readyReadStandardOutput,
&QtcProcess::readyReadStandardOutput,
this,
&PythonLSInstallHelper::outputAvailable);
@@ -276,8 +276,8 @@ public:
m_process.start();
Core::MessageManager::writeDisrupting(
tr("Running \"%1 %2\" to install Python language server")
.arg(m_process.program(), m_process.arguments().join(' ')));
tr("Running \"%1\" to install Python language server")
.arg(m_process.commandLine().toUserOutput()));
m_killTimer.setSingleShot(true);
m_killTimer.start(5 /*minutes*/ * 60 * 1000);

2
src/plugins/qnx/qnxutils.cpp
View File

@@ -127,7 +127,7 @@ EnvironmentItems QnxUtils::qnxEnvironmentFromEnvFile(const QString &fileName)
return items;
// parsing process output
QTextStream str(&process);
QTextStream str(process.ioDevice());
while (!str.atEnd()) {
QString line = str.readLine();
int equalIndex = line.indexOf(QLatin1Char('='));

5
src/plugins/winrt/winrtdevice.cpp
View File

@@ -145,9 +145,8 @@ void WinRtDeviceFactory::autoDetect()
if (!m_process) {
qCDebug(winrtDeviceLog) << __FUNCTION__ << "Creating process";
m_process = new Utils::QtcProcess(this);
connect(m_process, &QProcess::errorOccurred, this, &WinRtDeviceFactory::onProcessError);
connect(m_process, QOverload<int, QProcess::ExitStatus>::of(&QProcess::finished),
this, &WinRtDeviceFactory::onProcessFinished);
connect(m_process, &QtcProcess::errorOccurred, this, &WinRtDeviceFactory::onProcessError);
connect(m_process, &QtcProcess::finished, this, &WinRtDeviceFactory::onProcessFinished);
}
const CommandLine cmd{runnerFilePath, {"--list-devices"}};

11
src/plugins/winrt/winrtrunnerhelper.cpp
View File

@@ -211,12 +211,11 @@ void WinRtRunnerHelper::startWinRtRunner(const RunConf &conf)
appendMessage(cmdLine.toUserOutput(), NormalMessageFormat);
if (connectProcess) {
connect(process, &QProcess::started, this, &WinRtRunnerHelper::started);
connect(process, QOverload<int, QProcess::ExitStatus>::of(&QProcess::finished),
this, &WinRtRunnerHelper::onProcessFinished);
connect(process, &QProcess::errorOccurred, this, &WinRtRunnerHelper::onProcessError);
connect(process, &QProcess::readyReadStandardOutput, this, &WinRtRunnerHelper::onProcessReadyReadStdOut);
connect(process, &QProcess::readyReadStandardError, this, &WinRtRunnerHelper::onProcessReadyReadStdErr);
connect(process, &QtcProcess::started, this, &WinRtRunnerHelper::started);
connect(process, &QtcProcess::finished, this, &WinRtRunnerHelper::onProcessFinished);
connect(process, &QtcProcess::errorOccurred, this, &WinRtRunnerHelper::onProcessError);
connect(process, &QtcProcess::readyReadStandardOutput, this, &WinRtRunnerHelper::onProcessReadyReadStdOut);
connect(process, &QtcProcess::readyReadStandardError, this, &WinRtRunnerHelper::onProcessReadyReadStdErr);
}
process->setUseCtrlCStub(true);