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());
}
ScriptResolver::ScriptResolver(const QString& exe) :
Tomahawk::Resolver()
, m_cmd( exe )
, m_num_restarts( 0 )
, m_msgsize( 0 )
, m_ready( false )
, m_stopped( false )
{
qDebug() << Q_FUNC_INFO << exe;
connect( &m_proc, SIGNAL(readyReadStandardError()), SLOT(readStderr()) );
connect( &m_proc, SIGNAL(readyReadStandardOutput()), SLOT(readStdout()) );
connect( &m_proc, SIGNAL(finished(int,QProcess::ExitStatus)), SLOT(cmdExited(int,QProcess::ExitStatus)) );
m_proc.start( m_cmd );
}
QTerminal::QTerminal(QWidget *parent, Qt::WindowFlags f) : QTextEdit(parent) {
setWindowFlags(f);
cmdStr = "";
shell = new QProcess();
shell->setProcessChannelMode(QProcess::MergedChannels);
QObject::connect(shell, SIGNAL(readyReadStandardOutput()), this, SLOT(readStandardOut()));
QObject::connect(shell, SIGNAL(readyReadStandardError()), this, SLOT(readStandardErr()));
shell->start("cmd.exe", QStringList() << "", QIODevice::ReadWrite);
//this->insertPlainText("TERMINAL VERY ALPHA QUALITY ON WIN32!\r\n");
// This var protects against mouse interference with the cursor
curCursorLoc = this->textCursor();
inputCharCount = 0;
histLocation = -1;
tempCmd = "";
}
//----------------------------------------------------
void MainWindow::startUsbService()
{
mServiceStartError = false;
ui->btnBootstrapUSB->setEnabled(false);
ui->btnBootstrapUSB->setText("Starting...");
qApp->processEvents();
if (!mADBProcess)
{
mADBProcess = new QProcess(this);
connect(mADBProcess, SIGNAL(finished(int, QProcess::ExitStatus)), this, SLOT(onADBProcessFinishes()));
connect(mADBProcess, SIGNAL(readyReadStandardOutput()), this, SLOT(onADBProcessReadyRead()));
connect(mADBProcess, SIGNAL(readyReadStandardError()), this, SLOT(onADBErrorReadyRead()));
}
UpdateProcess::UpdateProcess(QObject *parent)
: QProcess(parent)
{
_currentCommand = NoCommand;
_socksPort = 0;
connect(this, SIGNAL(readyReadStandardError()),
this, SLOT(readStandardError()));
connect(this, SIGNAL(readyReadStandardOutput()),
this, SLOT(readStandardOutput()));
connect(this, SIGNAL(finished(int, QProcess::ExitStatus)),
this, SLOT(onFinished(int, QProcess::ExitStatus)));
setEnvironment(systemEnvironment());
}
//----------------------------------------------------
QProcess* MainWindow::runAdb(const QStringList& params)
{
QProcess* process = new QProcess(this);
connect(process, SIGNAL(readyReadStandardOutput()), this, SLOT(onADBProcessReadyRead()));
connect(process, SIGNAL(readyReadStandardError()), this, SLOT(onADBErrorReadyRead()));
#ifndef PLAT_APPLE
process->start(ADB_PATH, params);
#else
process->start(QDir(QCoreApplication::applicationDirPath()).absolutePath() + "/" + ADB_PATH, params);
#endif
return process;
}
ProcessHandler::ProcessHandler(AppInstance* app,
const QString& projectPath,
Natron::OutputEffectInstance* writer)
: _app(app)
,_process(new QProcess)
,_writer(writer)
,_ipcServer(0)
,_bgProcessOutputSocket(0)
,_bgProcessInputSocket(0)
,_earlyCancel(false)
,_processLog()
{
///setup the server used to listen the output of the background process
_ipcServer = new QLocalServer();
QObject::connect(_ipcServer,SIGNAL(newConnection()),this,SLOT(onNewConnectionPending()));
QString serverName;
int randomNumber = std::rand();
{
QTemporaryFile tmpf(NATRON_APPLICATION_NAME "_OUTPUT_PIPE_" + QString::number(randomNumber));
tmpf.open();
serverName = tmpf.fileName();
}
_ipcServer->listen(serverName);
QStringList processArgs;
processArgs << projectPath << "-b" << "-w" << writer->getName().c_str();
processArgs << "--IPCpipe" << (_ipcServer->fullServerName());
///connect the useful slots of the process
QObject::connect(_process,SIGNAL(readyReadStandardOutput()),this,SLOT(onStandardOutputBytesWritten()));
QObject::connect(_process,SIGNAL(readyReadStandardError()),this,SLOT(onStandardErrorBytesWritten()));
QObject::connect(_process,SIGNAL(error(QProcess::ProcessError)),this,SLOT(onProcessError(QProcess::ProcessError)));
QObject::connect(_process,SIGNAL(finished(int,QProcess::ExitStatus)),this,SLOT(onProcessEnd(int,QProcess::ExitStatus)));
///start the process
_processLog.push_back("Starting background rendering: " + QCoreApplication::applicationFilePath());
_processLog.push_back(" ");
for (int i = 0; i < processArgs.size(); ++i) {
_processLog.push_back(processArgs[i] + " ");
}
_process->start(QCoreApplication::applicationFilePath(),processArgs);
}
void KVirtual::startVde( const QString & vswitch )
{
uint id = getID();
KVirtualProcess * process = new KVirtualProcess( id, KVirtualProcess::SWITCH );
QStringList args;
QDir dir( vswitch );
QString buffer;
if ( dir.exists() )
{
m_view->addError( "Virtual switch is already exists but is not handled by me" );
return;
}
args << "-F" << "-sock" << vswitch;
process->setProgram( Settings::vde_switch_exe(), args );
process->setOutputChannelMode( KProcess::SeparateChannels );
process->setDataDir( vswitch );
connect( process,
SIGNAL( readyReadStandardOutput( uint ) ),
SLOT( readData( uint ) )
);
connect( process,
SIGNAL( readyReadStandardError( uint ) ),
SLOT( readError( uint ) )
);
connect( process,
SIGNAL( finished( uint, int, QProcess::ExitStatus ) ),
SLOT( closeProcess( uint, int, QProcess::ExitStatus ) )
);
connect( process,
SIGNAL( started( uint ) ),
SLOT( readStarted( uint ) )
);
m_view->addOutput( process->program().join( " " ) );
process->start();
m_processes[id] = process;
if ( process->error() == QProcess::FailedToStart || process->state() == QProcess::NotRunning )
{
buffer.setNum( id );
buffer.prepend( "Process" );
buffer.append( " failed to start" );
m_view->addError( buffer );
}
}
GdbDebugger::GdbDebugger(LiteApi::IApplication *app, QObject *parent) :
LiteApi::IDebugger(parent),
m_liteApp(app),
m_envManager(0)
{
m_process = new QProcess(this);
m_asyncModel = new QStandardItemModel(this);
m_asyncItem = new QStandardItem;
m_asyncModel->appendRow(m_asyncItem);
/*
m_asyncModel->setHeaderData(0,Qt::Horizontal,"Reason");
m_asyncModel->setHeaderData(1,Qt::Horizontal,"Address");
m_asyncModel->setHeaderData(2,Qt::Horizontal,"Function");
m_asyncModel->setHeaderData(3,Qt::Horizontal,"File");
m_asyncModel->setHeaderData(4,Qt::Horizontal,"Line");
m_asyncModel->setHeaderData(5,Qt::Horizontal,"Thread ID");
m_asyncModel->setHeaderData(6,Qt::Horizontal,"Stoped Threads");
*/
m_varsModel = new QStandardItemModel(0,3,this);
m_varsModel->setHeaderData(0,Qt::Horizontal,"Name");
m_varsModel->setHeaderData(1,Qt::Horizontal,"Value");
m_varsModel->setHeaderData(2,Qt::Horizontal,"Type");
m_watchModel = new QStandardItemModel(0,3,this);
m_watchModel->setHeaderData(0,Qt::Horizontal,"Name");
m_watchModel->setHeaderData(1,Qt::Horizontal,"Value");
m_watchModel->setHeaderData(2,Qt::Horizontal,"Type");
m_framesModel = new QStandardItemModel(0,5,this);
m_framesModel->setHeaderData(0,Qt::Horizontal,"Level");
m_framesModel->setHeaderData(1,Qt::Horizontal,"Address");
m_framesModel->setHeaderData(2,Qt::Horizontal,"Function");
m_framesModel->setHeaderData(3,Qt::Horizontal,"File");
m_framesModel->setHeaderData(4,Qt::Horizontal,"Line");
m_libraryModel = new QStandardItemModel(0,2,this);
m_libraryModel->setHeaderData(0,Qt::Horizontal,"Id");
m_libraryModel->setHeaderData(1,Qt::Horizontal,"Thread Groups");
m_gdbinit = false;
m_gdbexit = false;
connect(app,SIGNAL(loaded()),this,SLOT(appLoaded()));
connect(m_process,SIGNAL(started()),this,SIGNAL(debugStarted()));
connect(m_process,SIGNAL(finished(int)),this,SLOT(finished(int)));
connect(m_process,SIGNAL(readyReadStandardError()),this,SLOT(readStdError()));
connect(m_process,SIGNAL(readyReadStandardOutput()),this,SLOT(readStdOutput()));
}
bool FloppyAction::startProcess()
{
DEBUGSETUP;
connect(theProcess, SIGNAL(finished(int, QProcess::ExitStatus)),
this, SLOT(processDone(int, QProcess::ExitStatus)));
connect(theProcess, SIGNAL(readyReadStandardOutput()),
this, SLOT(readStdOut()));
connect(theProcess, SIGNAL(readyReadStandardError()),
this, SLOT(readStdErr()));
theProcess->setEnv( QStringLiteral( "LC_ALL" ), QStringLiteral( "C" ) ); // We need the untranslated output of the tool
theProcess->setOutputChannelMode(KProcess::SeparateChannels);
theProcess->start();
return (theProcess->exitStatus() == QProcess::NormalExit);
}
void DebugView::runDebugger( QString const& newWorkingDirectory,
QString const& newTarget,
QString const& newArguments )
{
m_workingDirectory = newWorkingDirectory;
m_target = newTarget;
m_arguments = newArguments;
if( m_state == none )
{
m_outBuffer.clear();
m_errBuffer.clear();
m_errorList.clear();
//create a process to control GDB
m_debugProcess = new QProcess( this );
m_debugProcess->setWorkingDirectory( m_workingDirectory );
//use the shell to find gdb for us, rather than launching gdb directly
const char* shell = getenv( "SHELL" );
if( shell == NULL )
{
shell = "/bin/sh";
}
//prepare the m_arguments to pass to shell
QStringList args;
args.append( "-c" );
args.append( "gdb" );
connect( m_debugProcess, SIGNAL( error(QProcess::ProcessError) ),
this, SLOT( slotError() ) );
connect( m_debugProcess, SIGNAL( readyReadStandardError() ),
this, SLOT( slotReadDebugStdErr() ) );
connect( m_debugProcess, SIGNAL( readyReadStandardOutput() ),
this, SLOT( slotReadDebugStdOut() ) );
connect( m_debugProcess, SIGNAL( finished(int,QProcess::ExitStatus) ),
this, SLOT( slotDebugFinished(int,QProcess::ExitStatus) ) );
m_debugProcess->start( shell, args );
m_nextCommands << "set pagination off";
m_state = ready;
}
void MainWindow::bash(QString command)
{
QProcess *p = new QProcess( this );
if (p)
{
p->setEnvironment( QProcess::systemEnvironment() );
p->setProcessChannelMode( QProcess::MergedChannels );
p->start( command );
p->waitForStarted();
connect( p, SIGNAL(readyReadStandardOutput()), this, SLOT(ReadOut()) );
connect( p, SIGNAL(readyReadStandardError()), this, SLOT(ReadErr()) );
}
}
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 MainWindow::on_downloadbutton_clicked()
{
QProcess *download = new QProcess();
if (download)
{
QString url;
url = ui->urlbox->text();
// qDebug()<<home;
qDebug()<<url;
download->start("wget", QStringList() << url << "-P" << "/home/arun/Downloads/arun");
qDebug()<<download;
download->waitForStarted();
connect( download, SIGNAL(readyReadStandardOutput()), this, SLOT(on_textBrowser_sourceChanged()) );
connect( download, SIGNAL(readyReadStandardError()), this, SLOT(ReadErr()) );
}
}
void ROSImportWizardPage::slotGenerateCodeBlocksProjectFile()
{
// Generate CodeBlocks Project File
m_runCmake = new QProcess();
connect(m_runCmake, SIGNAL(readyReadStandardOutput()),this, SLOT(slotUpdateStdText()));
connect(m_runCmake, SIGNAL(readyReadStandardError()),this, SLOT(slotUpdateStdError()));
m_hasValidCodeBlocksProjectFile = false;
if (ROSUtils::sourceWorkspace(m_runCmake, m_wsDir, d->m_ui.distributionComboBox->currentText()))
{
if (ROSUtils::generateCodeBlocksProjectFile(m_runCmake, m_srcDir, m_bldDir))
{
m_hasValidCodeBlocksProjectFile = true;
}
}
validChangedHelper();
slotActivated();
}
// ------------------------------------------------------------------------
bool OctaveWindow::startOctave()
{
if(octProcess.state()==QProcess::Running)
return true;
QString Program;
QStringList Arguments;
QString OctavePath = QDir::toNativeSeparators(QucsSettings.OctaveExecutable);
// Override Octave path by enviroment variable if it is set
if (QucsSettings.QucsOctave.isEmpty()) Program = OctavePath;
else Program = QucsSettings.QucsOctave;
Arguments << "--no-history" << "-i" << "-f" << "-p"
<< QDir::toNativeSeparators(QucsSettings.OctaveDir); // m-files location
disconnect(&octProcess, 0, 0, 0);
connect(&octProcess, SIGNAL(readyReadStandardError()), SLOT(slotDisplayErr()));
connect(&octProcess, SIGNAL(readyReadStandardOutput()), SLOT(slotDisplayMsg()));
connect(&octProcess, SIGNAL(finished(int)), SLOT(slotOctaveEnded(int)));
#ifdef __MINGW32__
QString sep(";"); // path separator
#else
QString sep(":");
#endif
// append process PATH, othewise Octave does not find gnuplot
QProcessEnvironment env = QProcessEnvironment::systemEnvironment();
env.insert("PATH", env.value("PATH") + sep + QucsSettings.BinDir );
octProcess.setProcessEnvironment(env);
output->clear();
qDebug() << "Command :" << Program << Arguments.join(" ");
octProcess.start(Program, Arguments);
octProcess.waitForStarted();
if(octProcess.state()!=QProcess::Running) {
output->setText(tr("ERROR: Failed to execute \"%1\"").arg(Program));
return false;
}
adjustDirectory();
return true;
}
/*
Uploader handles uploading a binary image to a board. It fires up a QProcess
and runs the uploader with flags determined by settings in Preferences.
*/
Uploader::Uploader(MainWindow *mainWindow) : QDialog( 0 )
{
this->mainWindow = mainWindow;
setupUi(this);
connect(this, SIGNAL(finished(int)), this, SLOT(onDialogClosed()));
connect(&uploader, SIGNAL(readyReadStandardOutput()), this, SLOT(filterOutput()));
connect(&uploader, SIGNAL(readyReadStandardError()), this, SLOT(filterError()));
connect(&uploader, SIGNAL(finished(int, QProcess::ExitStatus)), this, SLOT(uploadFinished(int, QProcess::ExitStatus)));
connect(&uploader, SIGNAL(error(QProcess::ProcessError)), this, SLOT(onError(QProcess::ProcessError)));
connect(browseButton, SIGNAL(clicked()), this, SLOT(onBrowseButton()));
connect(uploadButton, SIGNAL(clicked()), this, SLOT(onUploadButton()));
QSettings settings;
QString lastFilePath = settings.value("last_firmware_upload", QDir::homePath()).toString();
browseEdit->setText(lastFilePath);
progressBar->reset();
resize(gridLayout->sizeHint());
}
LogTextEdit::LogTextEdit(QWidget *parent)
: QTextEdit(parent), notifier_(OutputReader::instance())
{
// set flags
setReadOnly(true);
setLineWrapMode(QTextEdit::NoWrap);
if (!notifier_.redirect())
{
setHtml("ERROR: Could not start output redirection");
notifier_.cancelRedirect();
return;
}
// setup slots
connect(¬ifier_, SIGNAL(readyReadStandardError()), this, SLOT(standardErrorReady()));
connect(¬ifier_, SIGNAL(readyReadStandardOutput()), this, SLOT(standardOutputReady()));
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RiuProcessMonitor::startMonitorWorkProcess(caf::UiProcess* pProcess)
{
setStatusMsg("N/A", caf::PROCESS_STATE_NORMAL);
if (m_monitoredProcess == pProcess) return;
m_monitoredProcess = pProcess;
if (!m_monitoredProcess) return;
connect(m_monitoredProcess, SIGNAL(signalStatusMsg(const QString&, int)), SLOT(slotShowProcStatusMsg(const QString&, int)));
connect(m_monitoredProcess, SIGNAL(readyReadStandardError()), SLOT(slotProcReadyReadStdErr()));
connect(m_monitoredProcess, SIGNAL(readyReadStandardOutput()), SLOT(slotProcReadyReadStdOut()));
m_terminatePushButton->setEnabled(true);
QString timeStamp = QTime::currentTime().toString("hh:mm:ss");
addStringToLog(timeStamp + " Process starting\n");
}
void PluginKateTextFilter::runFilter(KTextEditor::View *kv, const QString &filter)
{
m_strFilterOutput.clear();
m_stderrOutput.clear();
if (!m_pFilterProcess)
{
m_pFilterProcess = new KProcess;
connect (m_pFilterProcess, SIGNAL(readyReadStandardOutput()),
this, SLOT(slotFilterReceivedStdout()));
connect (m_pFilterProcess, SIGNAL(readyReadStandardError()),
this, SLOT(slotFilterReceivedStderr()));
connect (m_pFilterProcess, SIGNAL(finished(int,QProcess::ExitStatus)),
this, SLOT(slotFilterProcessExited(int,QProcess::ExitStatus)));
}
MainWindow::MainWindow(QWidget *parent) :
QMainWindow(parent),
ui(new Ui::MainWindow)
{
ui->setupUi(this);
this->statusBar()->setSizeGripEnabled(true);
program = "C:/ffmpeg/bin/ffprobe.exe";
programFFMPEG = "C:/ffmpeg/bin/ffmpeg.exe";
valid = false;
stopped = false;
infoProcess = new QProcess(this);
converssion = new QProcess(this);
duration = 0;
connect(infoProcess, SIGNAL(started()), this, SLOT(processStarted()));
connect(infoProcess,SIGNAL(readyReadStandardOutput()),this,SLOT(extractInformation()));
connect(converssion, SIGNAL(finished(int)), this, SLOT(encodingFinished()));
connect(converssion,SIGNAL(readyReadStandardError()),this,SLOT(readOutput()));
}
bool Terminal::initialize()
{
context->parentContext()->setContextProperty("Terminal",this);
process=new QProcess(this);
process->setProgram("bash");
process->setArguments(QStringList() << "-i" << "-s");
process->setWorkingDirectory(QDir::homePath());
//QStringList l=process->systemEnvironment();
//user=l.at(l.indexOf(QRegExp("^USER=.+")));
//user=user.mid(user.indexOf("=")+1);
//process->setReadChannelMode(QProcess::MergedChannels);
connect(process,SIGNAL(started()),this,SLOT(started()));
connect(process,SIGNAL(finished(int,QProcess::ExitStatus)),this,SLOT(finished(int,QProcess::ExitStatus)));
connect(process,SIGNAL(readyReadStandardOutput()),this,SLOT(readOutput()));
connect(process,SIGNAL(readyReadStandardError()),this,SLOT(readError()));
user="******";
return true;
}
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);
}
void cRunningScript::doLaunch ()
{
launchAfter = 0;
// connect some signals
connect (process, SIGNAL (readyReadStandardOutput ()),
this, SLOT (processScriptStdOutput ()));
connect (process, SIGNAL (readyReadStandardError ()),
this, SLOT (processScriptStdError ()));
connect(process, SIGNAL(bytesWritten (qint64)),
this, SLOT(stdinReady()));
connect (process, SIGNAL (finished (int, QProcess::ExitStatus)),
this, SLOT (finished (int, QProcess::ExitStatus)));
connect (process, SIGNAL (error (QProcess::ProcessError)),
this, SLOT (failed (QProcess::ProcessError)));
//start the process
process->start (command, args);
}
void ArchiverService::callRestoringProcess(QString sqlFileName)
{
pgdumpProc = new QProcess();
connect(pgdumpProc, SIGNAL(readyReadStandardError()), this, SLOT(readyReadStandardErrorSlot()));
connect(pgdumpProc, SIGNAL(finished(int,QProcess::ExitStatus)), this, SLOT(finishedRestoreSlot(int)));
arguments << "-U";
arguments << Database::getInstance().db.userName();
arguments << Database::getInstance().db.databaseName();
// psql: FATAL: Peer authentication failed for user "bbraces"
pgdumpProc->setStandardInputFile(sqlFileName);
QApplication::setOverrideCursor(Qt::WaitCursor);
pgdumpProc->start("psql", arguments);
pgdumpProc->waitForFinished();
QApplication::restoreOverrideCursor();
delete pgdumpProc;
}
void ProjectBuild::configureTask()
{
cmd->addLine("*** Running Cmake ***", Qt::darkGreen);
QDir dir;
dir.mkdir(pathTmp);
/**
* Copy kernel.cl file to build directory
*/
QString source(pathTmp);
source.remove(pathTmp.split("/").last());
source.append("kernel.cl");
QString dest = pathTmp + "/kernel.cl";
QFile file(source);
file.copy(dest);
StaticMethods::destroyObj(&proc);
proc = new QProcess();
proc->setWorkingDirectory(pathTmp);
QString program("cmake");
QStringList arguments;
/** If Windows **/
if(OS == 1)
{
proc->setProcessEnvironment(env);
arguments += "-G";
arguments += "NMake Makefiles";
}
arguments += "..";
/**
* Getting cmake output in real time
*/
connect(proc, SIGNAL(readyReadStandardError()), this, SLOT(slotUpdateError()));
connect(proc, SIGNAL(readyReadStandardOutput()), this, SLOT(slotUpdateText()));
connect(proc, SIGNAL(finished(int)), this, SLOT(slotBuildTask()));
proc->start(program, arguments);
}
ReportGenerator::ReportGenerator()
:mArchDoc( 0 )
{
connect( this, SIGNAL( templateGenerated( const QString& )),
this, SLOT( slotConvertTemplate( const QString& )));
mProcess.setOutputChannelMode( KProcess::SeparateChannels );
connect( &mProcess, SIGNAL( finished( int ) ),this, SLOT( trml2pdfFinished( int ) ) );
connect( &mProcess, SIGNAL( readyReadStandardOutput()), this, SLOT( slotReceivedStdout() ) );
connect( &mProcess, SIGNAL( readyReadStandardError()), this, SLOT( slotReceivedStderr() ) );
connect( &mProcess, SIGNAL( error ( QProcess::ProcessError )), this, SLOT( slotError( QProcess::ProcessError)));
mAddressProvider = new AddressProvider( this );
connect( mAddressProvider, SIGNAL( addresseeFound( const QString&, const KABC::Addressee& )),
this, SLOT( slotAddresseeFound( const QString&, const KABC::Addressee& ) ) );
connect( mAddressProvider, SIGNAL( finished(int) ),
this, SLOT( slotAddresseeSearchFinished(int)) );
}
CMakeBuildDirCreator::CMakeBuildDirCreator(const KUrl& srcDir, QWidget* parent, Qt::WindowFlags f)
: QDialog(parent, f), m_srcFolder(srcDir)
{
m_creatorUi = new Ui::CMakeBuildDirCreator;
m_creatorUi->setupUi( this );
m_creatorUi->buttonBox->button(QDialogButtonBox::Ok)->setEnabled(false);
QString cmakeBin=executeProcess("which", QStringList("cmake"));
setCMakeBinary(KUrl(cmakeBin));
connect(m_creatorUi->run, SIGNAL(clicked()), this, SLOT(runBegin()));
connect(m_creatorUi->cmakeBin, SIGNAL(textChanged(const QString &)), this, SLOT(updated()));
connect(m_creatorUi->buildFolder, SIGNAL(textChanged(const QString &)), this, SLOT(updated()));
connect(m_creatorUi->buildType, SIGNAL(currentIndexChanged(const QString &)), this, SLOT(updated()));
connect(&m_proc, SIGNAL(readyReadStandardError()), this, SLOT(addError()));
connect(&m_proc, SIGNAL(readyReadStandardOutput()), this, SLOT(addOutput()));
connect(&m_proc, SIGNAL(finished ( int , QProcess::ExitStatus )), this, SLOT(cmakeCommandDone ( int , QProcess::ExitStatus )));
updated();
}
void KVirtual::createVDisk( const QString & file, const QString & type, const QString & size )
{
uint id = getID();
KVirtualProcess * process = new KVirtualProcess( id, KVirtualProcess::CREATE_IMG );
QStringList opts;
QString buffer;
opts << "create";
opts << "-f" << type;
opts << file;
opts << size;
process->setProgram( Settings::qemu_img_creator_exe(), opts );
process->setOutputChannelMode( KProcess::SeparateChannels );
connect( process,
SIGNAL( readyReadStandardOutput( uint ) ),
SLOT( readData( uint ) )
);
connect( process,
SIGNAL( readyReadStandardError( uint ) ),
SLOT( readError( uint ) )
);
connect( process,
SIGNAL( finished( uint, int, QProcess::ExitStatus ) ),
SLOT( closeProcess( uint, int, QProcess::ExitStatus ) )
);
connect( process,
SIGNAL( started( uint ) ),
SLOT( readStarted( uint ) )
);
m_view->addOutput( process->program().join( " " ) );
process->start();
m_processes[id] = process;
if ( process->error() == QProcess::FailedToStart || process->state() == QProcess::NotRunning )
{
buffer.setNum( id );
buffer.prepend( "Process" );
buffer.append( " failed to start" );
m_view->addError( buffer );
}
}
void MainWindow::startSynergy()
{
stopSynergy();
QString app;
QStringList args;
args << "-f" << "--debug" << appConfig().logLevelText();
if (!appConfig().screenName().isEmpty())
args << "--name" << appConfig().screenName();
if (appConfig().gameDevice())
{
args << "--game-device";
}
setSynergyProcess(new QProcess(this));
if ((synergyType() == synergyClient && !clientArgs(args, app))
|| (synergyType() == synergyServer && !serverArgs(args, app)))
{
stopSynergy();
return;
}
connect(synergyProcess(), SIGNAL(finished(int, QProcess::ExitStatus)), this, SLOT(synergyFinished(int, QProcess::ExitStatus)));
connect(synergyProcess(), SIGNAL(readyReadStandardOutput()), m_pLogDialog, SLOT(readSynergyOutput()));
connect(synergyProcess(), SIGNAL(readyReadStandardError()), m_pLogDialog, SLOT(readSynergyOutput()));
m_pLogDialog->append(tr("\n\nRunning synergy: %1 %2\n\n").arg(app).arg(args.join(" ")));
synergyProcess()->start(app, args);
if (!synergyProcess()->waitForStarted())
{
stopSynergy();
QMessageBox::warning(this, tr("Program can not be started"), QString(tr("The executable<br><br>%1<br><br>could not be successfully started, although it does exist. Please check if you have sufficient permissions to run this program.").arg(app)));
return;
}
setSynergyState(synergyConnected);
}
