PrologThread::PrologThread(qintptr socketId, QString prologPath, QObject *parent) :
QThread(parent), _socketId(socketId), _prologPath(prologPath), _cmdSize(0)
{
// We initialize client's prolog environemt
_process = new QProcess;
QObject::connect(this, SIGNAL(started()), this, SLOT(startProcess()));
QObject::connect(_process, SIGNAL(readyReadStandardOutput()), this, SLOT(readStdOut()));
QObject::connect(_process, SIGNAL(readyReadStandardError()), this, SLOT(readErrOut()));
QObject::connect(_process, SIGNAL(started()), this, SLOT(processStarted()));
QObject::connect(_process, SIGNAL(error(QProcess::ProcessError)), this, SLOT(processError(QProcess::ProcessError)));
_process->setProcessChannelMode(QProcess::MergedChannels);
_process->setProgram(_prologPath);
_process->setProcessEnvironment(QProcessEnvironment::systemEnvironment());
_process->setWorkingDirectory(QDir::homePath());
}
void TarsnapClient::run()
{
_process = new QProcess();
_process->setProcessChannelMode(QProcess::MergedChannels);
_process->setProgram(_command);
_process->setArguments(_arguments);
LOG << tr("Executing [%1 %2]").arg(_process->program()).arg(_process->arguments().join(' ')) << DELIMITER;
_process->start();
if(_process->waitForStarted(DEFAULT_TIMEOUT_MS))
{
emit started(_uuid);
}
else
{
processError();
goto cleanup;
}
if(_requiresPassword)
{
QByteArray password( _password.toUtf8() + "\n" );
_process->write( password.data(), password.size() );
}
if(_process->waitForFinished(-1))
{
readProcessOutput();
processFinished();
}
else
{
processError();
goto cleanup;
}
cleanup:
delete _process;
_process = 0;
}
void EmulApp::startSoundServer()
{
if (sndThr) delete sndThr, sndThr = 0;
sndThr = new SndThr(this);
sndThr->start();
if (soundServerProc) delete soundServerProc;
soundServerProc = new QProcess(this);
soundServerProc->setProcessChannelMode(QProcess::MergedChannels);
connect(soundServerProc, SIGNAL(readyRead()), this, SLOT(soundServerHasOutput()));
connect(soundServerProc, SIGNAL(error(QProcess::ProcessError)), this, SLOT(processError(QProcess::ProcessError)));
connect(soundServerProc, SIGNAL(finished(int, QProcess::ExitStatus)), this, SLOT(processDied()));
QStringList args;
#ifdef Q_OS_WIN
soundServerProc->start("SoundServer.exe", args, QIODevice::ReadOnly);
#elif defined(Q_OS_DARWIN)
if (QFile::exists("FSMEmulator.app/Contents/MacOS/SoundServer"))
soundServerProc->start("FSMEmulator.app/Contents/MacOS/SoundServer", args, QIODevice::ReadOnly);
else
soundServerProc->start("./SoundServer", args, QIODevice::ReadOnly);
#else /* LINUX */
soundServerProc->start("./SoundServer", args, QIODevice::ReadOnly);
#endif
Log() << "Starting SoundServer...\n";
soundServerProc->waitForStarted(10000);
if (soundServerProc->state() == QProcess::Running) {
#ifdef Q_OS_WIN
int pid = soundServerProc->pid()->dwProcessId;
#else
int pid = soundServerProc->pid();
#endif
Log() << "Started SoundServer with PID " << pid << "\n";
} else {
QString errStr;
switch (soundServerProc->error()) {
case QProcess::FailedToStart: errStr = "Process failed to start"; break;
case QProcess::Crashed: errStr = "Process crashed after starting"; break;
case QProcess::Timedout: errStr = "Waiting for the process timed out"; break;
default: errStr = "Unknown error";
}
throw Exception("Could not start SoundServer: " + errStr);
}
}
bool Client::connectToServer(const QString &serverName)
{
if (!m_jsonRpcClient) {
m_jsonRpcClient = new JsonRpcClient(this);
connect(m_jsonRpcClient, SIGNAL(resultReceived(QJsonObject)),
SLOT(processResult(QJsonObject)));
connect(m_jsonRpcClient, SIGNAL(notificationReceived(QJsonObject)),
SLOT(processNotification(QJsonObject)));
connect(m_jsonRpcClient, SIGNAL(errorReceived(QJsonObject)),
SLOT(processError(QJsonObject)));
connect(m_jsonRpcClient, SIGNAL(connectionStateChanged()),
SIGNAL(connectionStateChanged()));
}
return m_jsonRpcClient->connectToServer(serverName);
}
QQmlDebugProcess::QQmlDebugProcess(const QString &executable, QObject *parent)
: QObject(parent)
, m_executable(executable)
, m_started(false)
, m_port(0)
, m_maximumBindErrors(0)
, m_receivedBindErrors(0)
{
m_process.setProcessChannelMode(QProcess::MergedChannels);
m_timer.setSingleShot(true);
m_timer.setInterval(5000);
connect(&m_process, SIGNAL(readyReadStandardOutput()), this, SLOT(processAppOutput()));
connect(&m_process, SIGNAL(error(QProcess::ProcessError)),
this, SLOT(processError(QProcess::ProcessError)));
connect(&m_timer, SIGNAL(timeout()), SLOT(timeout()));
}
void Dialog::startSlave()
{
if (serial.portName() != serialPortComboBox->currentText()) {
serial.close();
serial.setPortName(serialPortComboBox->currentText());
if (!serial.open(QIODevice::ReadWrite)) {
processError(tr("Can't open %1, error code %2")
.arg(serial.portName()).arg(serial.error()));
return;
}
}
runButton->setEnabled(false);
statusLabel->setText(tr("Status: Running, connected to port %1.")
.arg(serialPortComboBox->currentText()));
}
bool Process::engineProcessStart(const QString& fullPath, const QString& workingDir, const QStringList& argList)
{
DEBUG_FUNC_NAME
connect(process_, SIGNAL(finished(int, QProcess::ExitStatus)),
this, SLOT(processFinished(int, QProcess::ExitStatus)));
connect(process_, SIGNAL(error(QProcess::ProcessError)),
this, SLOT(processError(QProcess::ProcessError)));
process_->setWorkingDirectory(workingDir);
// NOTE: start() function without args not parse correctly filepath with spaces, Qt bug?
process_->start(fullPath, argList, QProcess::Unbuffered | QProcess::ReadOnly);
processPid_ = process_->processId();
return true;
}
void HandshakeResponder::responderParseHandshakeFinished(){ //R:3 parse
m_timeout.stop();
disconnect(m_socket, &AbstractLink::readyRead, this, 0);
QByteArray cypherResponse;
m_socketStream >> cypherResponse;
if(isError(cypherResponse))return;
QByteArray clearResponse = gcmDecrypt(cypherResponse);
if(clearResponse.isEmpty()) return;
else if(clearResponse.size() == 1 && clearResponse.at(0) == (char)HandshakeFinished){
emit success();
}else{
processError(UndefinedError);
}
}
void NTStatsServer::processStatsMessage(int nIndex)
{
// Handle Stats Message here
StatsServerMessage* msgChannel = fdArray_[nIndex].msgChannel_;
if (!msgChannel)
return;
if (statsMsgHandler_.processStatsMessage(*msgChannel) != PR_TRUE)
{
processError(nIndex);
}
else
{
// Start a new Async Operation now
startAsyncReadOperation(nIndex);
}
return;
}
int MainWindow::startRun()
{
ui->lbInfo->setText(gainstart);
p = new QProcess;
connect(p, SIGNAL(readyReadStandardOutput()), this, SLOT(redFromStdOut()));
connect(p, SIGNAL(readyReadStandardError()), this, SLOT(redFromStdErr()));
connect(p, SIGNAL(error(QProcess::ProcessError)), this, SLOT(processError(QProcess::ProcessError)));
connect(p, SIGNAL(finished(int,QProcess::ExitStatus)), this, SLOT(processFinished(int,QProcess::ExitStatus)));
p->start(filename);
bStart = p->waitForStarted();
//bFinish = p->waitForFinished(-1);
if(bStart)
return 1;
else
return -1;
// return 1;
}
void CTypeChecker::Visit(const CClassDeclaration *classDeclaration) {
const CSymbol* classSymbol = classDeclaration->ClassName->Symbol;
currentClass = *find<CClassInfo,&CClassInfo::Name>(table.Classes, classSymbol);
if (isCyclicInheritance(classSymbol)) {
processError("cyclic inheritance for class '" + classSymbol->GetName() + "'", classDeclaration);
}
if (classDeclaration->BaseClassName != nullptr) {
classDeclaration->BaseClassName->Accept(this);
}
classDeclaration->ClassName->Accept(this);
if (classDeclaration->VarDeclarationList != nullptr) {
classDeclaration->VarDeclarationList->Accept(this);
}
if (classDeclaration->MethodDeclarationList != nullptr) {
classDeclaration->MethodDeclarationList->Accept(this);
}
}
void ProcessManager::runProcess(QString path, QString args)
{
if(process)
{
disconnect(process, SIGNAL(started()), this, SLOT(processStarted()));
disconnect(process, SIGNAL(errorOccurred(QProcess::ProcessError)), this, SLOT(processError(QProcess::ProcessError)));
disconnect(process, SIGNAL(finished(int)), this, SLOT(processFinished(int)));
delete process;
}
process = new QProcess(this);
process->setProcessChannelMode(QProcess::MergedChannels);
connect(process, SIGNAL(started()), this, SLOT(processStarted()));
connect(process, SIGNAL(errorOccurred(QProcess::ProcessError)), this, SLOT(processError(QProcess::ProcessError)));
connect(process, SIGNAL(finished(int)), this, SLOT(processFinished(int)));
QStringList arguments = args.split(" ",QString::SkipEmptyParts);
process->start(path, arguments);
}
unsigned long InetAddress::hostToAddr (const char* hostname) const
{
// convert a.b.c.d notation to ip address
unsigned long ipaddr = inet_addr(hostname);
if (ipaddr == INADDR_NONE)
{
// failed. try convert from hostname to ip address
hostent* h = gethostbyname(hostname);
if (!h)
{
processError("InetAddress::hostToAddr");
}
ipaddr = *((unsigned long*) h->h_addr_list[0]);
}
return ipaddr;
}
void NXClientLib::invokeNXSSH(QString publicKey, QString serverHost, bool encryption, QByteArray key, int port)
{
QStringList arguments;
proxyData.server = serverHost;
if (publicKey == "default") {
usingHardcodedKey = true;
}
if (publicKey == "default" || publicKey == "supplied") {
if (publicKey == "default")
cerr << tr("WARNING: Using hardcoded NoMachine public key.").toStdString() << endl;
keyFile = new QTemporaryFile;
keyFile->open();
arguments << "-nx" << "-i" << keyFile->fileName();
if (publicKey == "default")
keyFile->write(cert);
else
keyFile->write(key);
keyFile->close();
} else {
arguments << "-i" << publicKey;
}
if (encryption == true) {
arguments << "-B";
session.setEncryption(true);
} else
session.setEncryption(false);
connect(&nxsshProcess, SIGNAL(started()), this, SLOT(processStarted()));
connect(&nxsshProcess, SIGNAL(error(QProcess::ProcessError)), this, SLOT(processError(QProcess::ProcessError)));
connect(&nxsshProcess, SIGNAL(readyReadStandardOutput()), this, SLOT(processParseStdout()));
connect(&nxsshProcess, SIGNAL(readyReadStandardError()), this, SLOT(processParseStderr()));
nxsshProcess.setEnvironment(nxsshProcess.systemEnvironment());
arguments << QString("-p %1").arg(port) << QString("nx@" + serverHost);
nxsshProcess.start(NXSSH_BIN, arguments);
}
GnuplotWidget::GnuplotWidget(QWidget *parent, QSqlDatabase *argDatabase, int argObsobjID, QString argTitle) :
QWidget(parent),
ui(new Ui::GnuplotWidget)
{
mDatabase = argDatabase;
mObsobjID = argObsobjID;
ui->setupUi(this);
QString wkString;
wkString.clear();
wkString.append(this->getObstblName());
wkString.append(" - ");
wkString.append(argTitle);
this->setWindowTitle((const QString)wkString);
mProcess = new QProcess(this);
mPathname.clear();
mPathname.append("/usr/local/bin/gnuplot");
// mArgument.clear();
// mArgument.append("");
m_running = false;
connect(mProcess, SIGNAL(readyReadStandardOutput()),
this, SLOT(refreshWidget()));
connect(mProcess, SIGNAL(finished(int, QProcess::ExitStatus)),
this, SLOT(processFinished(int, QProcess::ExitStatus)));
connect(mProcess, SIGNAL(error(QProcess::ProcessError)),
this, SLOT(processError(QProcess::ProcessError)));
if (!m_running)
{
m_running = true;
mProcess->start(mPathname);
}
// QByteArray data = mProcess->readAll();
// QString str;
// str.clear();
// str.append(data.data());
this->called_when_DatabaseUpdated();
}
void DGLRunAppProject::startDebugging() {
// randomize connection port
int port = rand() % (0xffff - 1024) + 1024;
m_process = new DGLDebugeeQTProcess(port, m_EglMode);
m_process->setParent(this);
CONNASSERT(m_process, SIGNAL(processReady()), this,
SLOT(processReadyHandler()));
CONNASSERT(m_process, SIGNAL(processError(std::string)), this,
SLOT(processErrorHandler(std::string)));
CONNASSERT(m_process, SIGNAL(processFinished(int)), this,
SLOT(processExitHandler(int)));
CONNASSERT(m_process, SIGNAL(processCrashed()), this,
SLOT(processCrashHandler()));
m_process->run(getExecutable(), getPath(), getCommandLineArgVector(), getSkipProcessesCount());
}
void NTStatsServer::startAsyncReadOperation(int nIndex)
{
StatsFileDesc* statFileDesc = &fdArray_[nIndex];
if (statFileDesc->state_ != STAT_HANDLE_WAIT_READING)
return;
StatsServerMessage* msgChannel = statFileDesc->msgChannel_;
PRBool fSuccess = msgChannel->asyncRecvFromServer();
if (fSuccess == PR_TRUE)
{
processStatsMessage(nIndex);
return;
}
if (msgChannel->isPendingRead() == PR_FALSE)
{
// Error Happened in IO
processError(nIndex);
}
return;
}
TermGdbAdapter::TermGdbAdapter(GdbEngine *engine)
: AbstractGdbAdapter(engine)
{
#ifdef Q_OS_WIN
// Windows up to xp needs a workaround for attaching to freshly started processes. see proc_stub_win
if (QSysInfo::WindowsVersion >= QSysInfo::WV_VISTA) {
m_stubProc.setMode(Utils::ConsoleProcess::Suspend);
} else {
m_stubProc.setMode(Utils::ConsoleProcess::Debug);
}
#else
m_stubProc.setMode(Utils::ConsoleProcess::Debug);
m_stubProc.setSettings(Core::ICore::settings());
#endif
connect(&m_stubProc, SIGNAL(processError(QString)), SLOT(stubError(QString)));
connect(&m_stubProc, SIGNAL(processStarted()), SLOT(handleInferiorSetupOk()));
connect(&m_stubProc, SIGNAL(wrapperStopped()), SLOT(stubExited()));
}
static void calculateAvgValue(ADC_HandleTypeDef *hadc, uint8_t position) {
uint64_t values[] = {0, 0, 0};
before = hadc->DMA_Handle->Instance->NDTR;
for (int i = position; i < ADC_HALF_BUFFER_SIZE + position; i++) {
values[i % 3] += adcBuffer[i];
}
for (int i = 0; i < 3; i++) {
adcResults[i] = values[i] * 3 / ADC_HALF_BUFFER_SIZE;
}
after = hadc->DMA_Handle->Instance->NDTR;
if (after > before) {
processError(2, 500, 500);
}
}
void FirewallCodeViewer::showDiff(const QString &sourceFileName, const QString &destinationFileName)
{
if (st->getDiffPath().isEmpty()) {
int ret = QMessageBox::warning(this,
tr("Could not start diff program"),
tr("You have not configured an external diff program yet.\n"
"Do you want to do it now?"),
QMessageBox::Yes,
QMessageBox::No
);
if (ret == QMessageBox::Yes) {
PrefsDialog pd(this);
pd.selectTab("Diff");
pd.exec();
}
return;
}
if (!QFileInfo(destinationFileName).isFile()) return;
QStringList args;
if (!QFileInfo(sourceFileName).isFile()) {
QString newSourceFileName = QFileDialog::getOpenFileName(
this,
tr("Select source file for diff..."),
st->getOpenFileDir());
if (!QFileInfo(newSourceFileName).isFile()) return;
args << newSourceFileName;
} else {
args << sourceFileName;
}
args << destinationFileName;
QProcess *process = new QProcess();
connect(process, SIGNAL(finished(int)), process, SLOT(deleteLater()));
connect(process, SIGNAL(error(QProcess::ProcessError)), this, SLOT(processError(QProcess::ProcessError)));
process->start(st->getDiffPath(), args);
}
QgsRunProcess::QgsRunProcess( const QString& action, bool capture )
: mProcess( nullptr )
, mOutput( nullptr )
{
// Make up a string from the command and arguments that we'll use
// for display purposes
QgsDebugMsg( "Running command: " + action );
mCommand = action;
mProcess = new QProcess;
if ( capture )
{
connect( mProcess, SIGNAL( error( QProcess::ProcessError ) ), this, SLOT( processError( QProcess::ProcessError ) ) );
connect( mProcess, SIGNAL( readyReadStandardOutput() ), this, SLOT( stdoutAvailable() ) );
connect( mProcess, SIGNAL( readyReadStandardError() ), this, SLOT( stderrAvailable() ) );
// We only care if the process has finished if we are capturing
// the output from the process, hence this connect() call is
// inside the capture if() statement.
connect( mProcess, SIGNAL( finished( int, QProcess::ExitStatus ) ), this, SLOT( processExit( int, QProcess::ExitStatus ) ) );
// Use QgsMessageOutput for displaying output to user
// It will delete itself when the dialog box is closed.
mOutput = QgsMessageOutput::createMessageOutput();
mOutput->setTitle( action );
mOutput->setMessage( tr( "<b>Starting %1...</b>" ).arg( action ), QgsMessageOutput::MessageHtml );
mOutput->showMessage( false ); // non-blocking
// get notification of delete if it's derived from QObject
QObject* mOutputObj = dynamic_cast<QObject *>( mOutput );
if ( mOutputObj )
{
connect( mOutputObj, SIGNAL( destroyed() ), this, SLOT( dialogGone() ) );
}
// start the process!
mProcess->start( action );
}
else
{
if ( ! mProcess->startDetached( action ) ) // let the program run by itself
void TgtProcessIntf::tgtMakeConnection()
{
std::shared_ptr<const TgtConnectionConfig> connectionConfig = std::dynamic_pointer_cast<const TgtConnectionConfig>(
_connectionConfig);
_proc = new QProcess(this);
connect(_proc, SIGNAL(readyReadStandardOutput()), this, SLOT(readFromStdout()));
connect(_proc, SIGNAL(readyReadStandardError()), this, SLOT(readFromStderr()));
connect(_proc, SIGNAL(error(QProcess::ProcessError)), this, SLOT(processError(QProcess::ProcessError)));
connect(_proc, SIGNAL(finished(int,QProcess::ExitStatus)), this, SLOT(processDone(int,QProcess::ExitStatus)));
_proc->setWorkingDirectory(connectionConfig->_workingDir.c_str());
QStringList args(connectionConfig->_args.c_str());
QProcessEnvironment env = QProcessEnvironment::systemEnvironment();
env.insert("TERM", "xterm");
env.insert("COLORTERM", "gnome-terminal");
_proc->setProcessEnvironment(env);
_proc->start(connectionConfig->_program.c_str(), args);
_processWriterThread = TgtThread::create(boost::protect(std::bind(&TgtProcessIntf::writerThread, this)));
}
ScreenSaver::ScreenSaver(wl_display *display, QObject *parent)
: QObject(parent)
, QtWaylandServer::wl_screensaver(display)
, m_compositor(nullptr)
, m_enabled(true)
, m_timeout(5*60*1000)
, m_timer(new QTimer(this))
, m_process(new QProcess(this))
{
m_timer->setInterval(m_timeout);
connect(m_timer, SIGNAL(timeout()),
this, SLOT(timeout()));
connect(m_process, SIGNAL(started()),
this, SLOT(processStarted()));
connect(m_process, SIGNAL(finished(int)),
this, SLOT(processFinished(int)));
connect(m_process, SIGNAL(error(QProcess::ProcessError)),
this, SLOT(processError(QProcess::ProcessError)));
}
void TarsnapClient::processFinished()
{
QString output(_processOutput);
switch (_process->exitStatus())
{
case QProcess::NormalExit:
if(!output.isEmpty())
LOG << tr("[%1 %2] finished with exit code %3 and output:\n%4").arg(_command)
.arg(_arguments.join(' ')).arg(_process->exitCode()).arg(output) << DELIMITER;
else
LOG << tr("[%1 %2] finished with exit code %3 and no output.").arg(_command)
.arg(_arguments.join(' ')).arg(_process->exitCode()) << DELIMITER;
emit finished(_uuid, _data, _process->exitCode(), output);
emit terminated(_uuid);
break;
case QProcess::CrashExit:
processError();
break;
}
}
void Dialog::sendRequest()
{
if (serial.portName() != serialPortComboBox->currentText()) {
serial.close();
serial.setPortName(serialPortComboBox->currentText());
if (!serial.open(QIODevice::ReadWrite)) {
processError(tr("Can't open %1, error code %2")
.arg(serial.portName()).arg(serial.error()));
return;
}
}
setControlsEnabled(false);
statusLabel->setText(tr("Status: Running, connected to port %1.")
.arg(serialPortComboBox->currentText()));
serial.write(requestLineEdit->text().toLocal8Bit());
timer.start(waitResponseSpinBox->value());
}
DemoApplication::DemoApplication(QString executableName, QString caption, QString imageName, QStringList args)
{
imagePath = imageName;
appCaption = caption;
if (executableName[0] == QLatin1Char('/'))
executablePath = executableName;
else
executablePath = QDir::cleanPath(QDir::currentPath() + QLatin1Char('/') + executableName);
arguments = args;
process.setProcessChannelMode(QProcess::ForwardedChannels);
QObject::connect( &process, SIGNAL(finished(int,QProcess::ExitStatus)),
this, SLOT(processFinished(int,QProcess::ExitStatus)));
QObject::connect( &process, SIGNAL(error(QProcess::ProcessError)),
this, SLOT(processError(QProcess::ProcessError)));
QObject::connect( &process, SIGNAL(started()), this, SLOT(processStarted()));
}
void Device::open_port(){
if (serial.portName() != "COM3") {
serial.close();
serial.setPortName("COM3");
if(serial.isOpen()){
//do nothing
}
else{
if (!serial.open(QIODevice::ReadWrite)) {
processError(QObject::tr("Can't open %1, error code %2")
.arg(serial.portName()).arg(serial.error()));
return;
}
}
if (!serial.setBaudRate(QSerialPort::Baud19200)) {
processError(QObject::tr("Can't set rate 19200 baud to port %1, error code %2")
.arg(serial.portName()).arg(serial.error()));
return;
}
if (!serial.setDataBits(QSerialPort::Data8)) {
processError(QObject::tr("Can't set 8 data bits to port %1, error code %2")
.arg(serial.portName()).arg(serial.error()));
return;
}
if (!serial.setParity(QSerialPort::NoParity)) {
processError(QObject::tr("Can't set no patity to port %1, error code %2")
.arg(serial.portName()).arg(serial.error()));
return;
}
if (!serial.setStopBits(QSerialPort::OneStop)) {
processError(QObject::tr("Can't set 1 stop bit to port %1, error code %2")
.arg(serial.portName()).arg(serial.error()));
return;
}
if (!serial.setFlowControl(QSerialPort::NoFlowControl)) {
processError(QObject::tr("Can't set no flow control to port %1, error code %2")
.arg(serial.portName()).arg(serial.error()));
return;
}
}
}
void ASIOReadBuffer::asioReadIntoChunk(const ErrorCode&error,std::size_t bytes_read) {
TCPSSTLOG(this,"rcv",&mNewChunk[mBufferPos],bytes_read,error);
mBufferPos+=bytes_read;
std::tr1::shared_ptr<MultiplexedSocket> thus(mParentSocket.lock());
if (thus) {
if (error) {
processError(&*thus,error);
} else {
if (mBufferPos>=mNewChunk.size()) {
assert(mBufferPos==mNewChunk.size());
processFullChunk(thus,mWhichBuffer,mNewChunkID,mNewChunk);
mNewChunk.resize(0);
mBufferPos=0;
readIntoFixedBuffer(thus);
} else {
readIntoChunk(thus);
}
}
} else {
delete this;
}
}
void DGLDebugeeQTProcess::handleProcessFinished(int code,
QProcess::ExitStatus status) {
m_PollTimer->stop();
if (status == QProcess::CrashExit) {
// this is loader process that crashed!
emit processCrashed();
} else {
// check in IPC if loader was successful
if (m_Loaded || m_SemLoader.try_wait()) {
IPCMessage* ipcMessage = (IPCMessage*)m_MappedRegion.get_address();
if (ipcMessage) {
static_assert(sizeof(char) == sizeof(ipcMessage->m_message[0]),
"Wrong IPC message element size");
if (!ipcMessage->m_ok) {
emit processError((char*)ipcMessage->m_message);
}
}
}
emit processFinished(code);
}
}
void MainWindow::solve()
{
if(_pr)
delete _pr;
ui->solve->setEnabled(false);
ui->markup->clear();
ui->solutions->clear();
_pr=new QProcess(this);
QString cmd = QString("EquationSolverConsole.exe");
if(!QFile::exists(cmd))
ui->solutions->append(tr("Enable to run utility: %1").arg(cmd));
//QString cmd = QString("cmd.exe");
QStringList args;
args << ui->equation->text();
_equation = ui->equation->text();
connect(_pr, SIGNAL(started()), SLOT(processStarted()));
connect(_pr, SIGNAL(error(QProcess::ProcessError)), SLOT(processError()));
connect(_pr, SIGNAL(finished(int)), SLOT(processFinished(int)));
_pr->setWorkingDirectory(QDir::currentPath());
_pr->start(cmd,args);
}
