MainWindow::MainWindow(QWidget *parent) :
QMainWindow(parent),
ui(new Ui::MainWindow)
{
ui->setupUi(this);
ping = new QProcess();
iperf = new QProcess();
timer = new QTimer();
timer->setSingleShot(true);
numTests = 0;
ui->udpBandwidthField->hide();
connect(ping,SIGNAL(readyReadStandardOutput()),this,SLOT(readPingOutput()));
connect(iperf,SIGNAL(readyReadStandardOutput()),this,SLOT(readIperfOutput()));
connect(ping,SIGNAL(readyReadStandardError()),this,SLOT(readError()));
connect(iperf,SIGNAL(readyReadStandardError()),this,SLOT(readError()));
connect(ping,SIGNAL(started()),this,SLOT(processStarted()));
connect(iperf,SIGNAL(started()),this,SLOT(processStarted()));
connect(ping,SIGNAL(finished(int,QProcess::ExitStatus)),this,SLOT(pingFinished(int,QProcess::ExitStatus)));
connect(iperf,SIGNAL(finished(int,QProcess::ExitStatus)),this,SLOT(iperfFinished(int,QProcess::ExitStatus)));
connect(ping,SIGNAL(error(QProcess::ProcessError)),this,SLOT(error(QProcess::ProcessError)));
connect(iperf,SIGNAL(error(QProcess::ProcessError)),this,SLOT(error(QProcess::ProcessError)));
connect(timer,SIGNAL(timeout()),this,SLOT(startPing()));
initPlot();
}
void MainWindow::on_btnStart_clicked()
{
if (!QFile(programPath).exists()) {
QMessageBox::warning(this,
tr("Невозможно запустить процесс"),
tr("Не найден файл программы.\n"
"Возможно, не указан путь к файлу gostunnel.exe"));
return;
}
if (ui->lwGroups->count() == 0) {
return;
}
QString el = ui->lwGroups->currentItem()->text();
QProcess *proc = connections.value(el);
if (proc->pid() <= 0) {
QDir wd = QDir(programPath);
wd.cdUp();
proc->setWorkingDirectory(wd.path());
QStringList args;
args << "--config" << programConfig
<< "-s" << el;
connect(proc, SIGNAL(error(QProcess::ProcessError)),
this, SLOT(processError(QProcess::ProcessError)));
connect(proc, SIGNAL(finished(int,QProcess::ExitStatus)),
this, SLOT(processFinished(int,QProcess::ExitStatus)));
connect(proc, SIGNAL(stateChanged(QProcess::ProcessState)),
this, SLOT(processStateChenged(QProcess::ProcessState)));
connect(proc, SIGNAL(readyReadStandardError()),
this, SLOT(processReadyReadError()));
connect(proc, SIGNAL(started()),
this, SLOT(processStarted()));
ui->lwGroups->currentItem()->setBackgroundColor(QColor::fromRgb(255, 233, 113));
proc->start(programPath, args);
}
void GdbTermEngine::setupEngine()
{
QTC_ASSERT(state() == EngineSetupRequested, qDebug() << state());
showMessage(_("TRYING TO START ADAPTER"));
// Currently, adapters are not re-used
// // We leave the console open, so recycle it now.
// m_stubProc.blockSignals(true);
// m_stubProc.stop();
// m_stubProc.blockSignals(false);
if (!prepareCommand())
return;
m_stubProc.setWorkingDirectory(startParameters().workingDirectory);
// Set environment + dumper preload.
m_stubProc.setEnvironment(startParameters().environment);
connect(&m_stubProc, SIGNAL(processError(QString)), SLOT(stubError(QString)));
connect(&m_stubProc, SIGNAL(processStarted()), SLOT(stubStarted()));
connect(&m_stubProc, SIGNAL(wrapperStopped()), SLOT(stubExited()));
// FIXME: Starting the stub implies starting the inferior. This is
// fairly unclean as far as the state machine and error reporting go.
if (!m_stubProc.start(startParameters().executable,
startParameters().processArgs)) {
// Error message for user is delivered via a signal.
handleAdapterStartFailed(QString());
return;
}
}
void MainWindow::pressedStartResumeButton()
{
if(!mProssesStarted && mProssesPaused)
{
mProcData.setURL(mURL->text());
mProcData.setFindString(mFoundText->text());
mProcData.setNumThread(mMaxThreadNumber->number());
mProcData.setMaxNumURL(mMaxUrlNumber->number());
mURL->setEnabled(false);
mFoundText->setEnabled(false);
mMaxThreadNumber->setEnabled(false);
mMaxUrlNumber->setEnabled(false);
mURLStatusTable->clear();
emit processStarted(mProcData);
}
else
{
if(!mProssesPaused)
{
emit processPaused();
}
else
{
emit processResumed();
}
}
mProssesStarted = true;
mProssesPaused = !mProssesPaused;
updateWidget();
}
void SshRemoteProcessRunnerPrivate::handleProcessStarted()
{
ASSERT_STATE(Connected);
setState(ProcessRunning);
emit processStarted();
}
MainWindow::MainWindow(QWidget *parent) :
QMainWindow(parent),
ui(new Ui::MainWindow)
{
ui->setupUi(this);
isfile = true; //代表是文件或者是文件夹
hasfile = false; // 代表该文件是ts 或者文件夹内有ts文件
ui->ConvertBar->setRange(0, 100);
m_CurrentValue = 0;
ui->ConvertBar->setValue(m_CurrentValue);
// Create process
// transcoding
mTranscodingProcess = new QProcess(this);
connect(mTranscodingProcess, SIGNAL(started()), this, SLOT(processStarted()));
connect(mTranscodingProcess,SIGNAL(readyReadStandardOutput()),this,SLOT(readyReadStandardOutput()));
connect(mTranscodingProcess, SIGNAL(finished(int)), this, SLOT(ConvertFinished()));
//线程log返回
mypathProcess = new PathProcess(this);
connect(mypathProcess, SIGNAL(Log(QString)), this, SLOT(Log(QString)));
connect(mypathProcess, SIGNAL(ThreadProcessBar(int)), this, SLOT(ThreadProcessBar(int)));
}
void SshRemoteProcessRunner::handleProcessStarted()
{
QSSH_ASSERT_AND_RETURN(d->m_state == Connected);
setState(ProcessRunning);
emit processStarted();
}
/*! \internal
*/
bool QProcessPrivate::startupNotification()
{
Q_Q(QProcess);
#if defined QPROCESS_DEBUG
qDebug("QProcessPrivate::startupNotification()");
#endif
if (startupSocketNotifier)
startupSocketNotifier->setEnabled(false);
if (processStarted()) {
processState = QProcess::Running;
emit q->started();
return true;
}
processState = QProcess::NotRunning;
processError = QProcess::FailedToStart;
emit q->error(processError);
#ifdef Q_OS_UNIX
// make sure the process manager removes this entry
findExitCode();
#endif
cleanup();
return false;
}
void UpdateDialog::accept()
{
QProcess * myProgress = new QProcess;
connect(myProgress, SIGNAL(error(QProcess::ProcessError)), this, SLOT(processError(QProcess::ProcessError)));
connect(myProgress, SIGNAL(started()), this, SLOT(processStarted()));
myProgress->start(m_installerFileName);
hide();
}
CommonCode::CommonCode( QWidget* parent ):
QWidget(parent)
{
// setting up the process component
_process.setReadChannelMode( QProcess::MergedChannels );
connect( &_process, SIGNAL(readyRead()), this, SLOT(readOutput()) );
connect( &_process, SIGNAL(started()), this, SLOT(processStarted()) );
connect( &_process, SIGNAL(finished(int,QProcess::ExitStatus)), this, SLOT(processFinished()) );
}
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);
}
LocalApplicationRunControl::LocalApplicationRunControl(RunConfiguration *rc, RunMode mode)
: RunControl(rc, mode), m_runMode(ApplicationLauncher::Console), m_running(false)
{
setIcon(QLatin1String(Constants::ICON_RUN_SMALL));
EnvironmentAspect *environment = rc->extraAspect<EnvironmentAspect>();
Utils::Environment env;
if (environment)
env = environment->environment();
m_applicationLauncher.setEnvironment(env);
connect(&m_applicationLauncher, SIGNAL(appendMessage(QString,Utils::OutputFormat)),
this, SLOT(slotAppendMessage(QString,Utils::OutputFormat)));
connect(&m_applicationLauncher, SIGNAL(processStarted()),
this, SLOT(processStarted()));
connect(&m_applicationLauncher, SIGNAL(processExited(int,QProcess::ExitStatus)),
this, SLOT(processExited(int,QProcess::ExitStatus)));
connect(&m_applicationLauncher, SIGNAL(bringToForegroundRequested(qint64)),
this, SLOT(bringApplicationToForeground(qint64)));
}
bool QProcessPrivate::waitForStarted(int)
{
Q_Q(QProcess);
if (processStarted())
return true;
if (processError == QProcess::FailedToStart)
return false;
setError(QProcess::Timedout);
return false;
}
AttachHelper::AttachHelper(const QString &gammaray, const QString &injector,
const QString &debuggee, const QStringList &arguments, QObject *parent)
: QObject(parent)
, m_timer(new QTimer(this))
, m_proc(new QProcess(this))
, m_gammaray(gammaray)
, m_injector(injector)
{
m_proc->setProcessChannelMode(QProcess::ForwardedChannels);
connect(m_proc, SIGNAL(started()), this, SLOT(processStarted()));
connect(m_proc, SIGNAL(finished(int)), this, SLOT(processFinished(int)));
m_proc->start(debuggee, arguments);
}
bool QProcessPrivate::waitForStarted(int)
{
Q_Q(QProcess);
if (processStarted())
return true;
if (processError == QProcess::FailedToStart)
return false;
processError = QProcess::Timedout;
q->setErrorString(QProcess::tr("Process operation timed out"));
return false;
}
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());
}
MainWindow::MainWindow(QWidget *parent) :
QMainWindow(parent),
ui(new Ui::MainWindow)
{
ui->setupUi(this);
lastcnf = new config();
crackingProcess = new QProcess(this);
initializeHashType(ui->comboBox);
initializeOutputType(ui->comboBox_2);
loadWordList();
ui->txtSalt->setDisabled(true);
ui->txtLog->installEventFilter(this);
//connect(ui->txtLog,SIGNAL(keyPressEvent()),this,SLOT(handleKeyPress()));
connect(ui->btnclipboard,SIGNAL(clicked()),this,SLOT(handleClipboardHash()));
connect(ui->btnBrowseInput,SIGNAL(clicked()),this,SLOT(handleOpenInput()));
connect(ui->btnBrowseOutput,SIGNAL(clicked()),this,SLOT(handleOpenOutput()));
connect(crackingProcess,SIGNAL(started()),this,SLOT(processStarted()));
connect(crackingProcess,SIGNAL(finished(int, QProcess::ExitStatus)),this,SLOT(processDone(int,QProcess::ExitStatus)));
connect(crackingProcess,SIGNAL(readyReadStandardOutput()),this,SLOT(showLog()));
connect(ui->btnAction,SIGNAL(clicked()),this,SLOT(startCracking()));
connect(ui->btnCreate,SIGNAL(clicked()),this,SLOT(createHashFile()));
connect(ui->btnAdd,SIGNAL(clicked()),this,SLOT(addWordList()));
connect(ui->btnRemove,SIGNAL(clicked()),this,SLOT(deleteWordList()));
connect(ui->btnBrowseSalt,SIGNAL(clicked()),this,SLOT(handleOpenSalt()));
connect(ui->btnBrowseProg,SIGNAL(clicked()),this,SLOT(handleOpenProg()));
connect(ui->btnUp,SIGNAL(clicked()),this,SLOT(moveWordUp()));
connect(ui->btnDown,SIGNAL(clicked()),this,SLOT(moveWordDown()));
ui->txtInputFile->setText(QStandardPaths::writableLocation(QStandardPaths::DesktopLocation) + "/input.txt");
ui->txtOutputFile->setText(QStandardPaths::writableLocation(QStandardPaths::DesktopLocation) + "/output.txt");
#ifdef Q_OS_WIN32
ui->txtProg->setText("hashcat-cli32.exe");
#endif
#ifdef Q_OS_DARWIN
ui->txtProg->setText("/usr/local/bin/hashcat");
#endif
if(lastcnf->lasthashpath != "")
ui->txtInputFile->setText(lastcnf->lasthashpath);
if(lastcnf->hashcatpath != "")
ui->txtProg->setText(lastcnf->hashcatpath);
if(lastcnf->separator != "")
ui->sep->setText(lastcnf->separator);
ui->tab_3->setFocus();
createActionText("idle");
if(lastcnf->lastdir != "")
lastdir = lastcnf->lastdir;
else
lastdir = QDir::currentPath();
}
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()));
}
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);
}
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()));
}
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)));
}
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 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);
}
bool KviKvsProcessAsyncOperation::start()
{
QStringList args;
QString szcmd;
if(m_pData->iFlags & KVI_KVS_PROCESSDESCRIPTOR_NOSHELL)
{
args = m_pData->szCommandline.split(" ", QString::SkipEmptyParts);
}
else
{
QString szShell = m_pData->szShell;
if(szShell.isEmpty())
{
#if defined(COMPILE_ON_WINDOWS) || defined(COMPILE_ON_MINGW)
// [01:26:00] <PragmaOff> btw, what is qt_winunicode ?
// [01:26:12] <kode54> Qt export specific to win32
// [01:26:27] <kode54> bool which indicates whether system is Unicode (NT) or not
// [01:26:58] <kode54> not sure if that's documented, but it is a public export
//
// [02:50:21] <kode54> if ( QApplication::winVersion() & Qt::WV_NT_based )
// [02:50:41] <kode54> I see another implementation using that, maybe it is the official way of detecting that :[
szShell = !(QSysInfo::WindowsVersion & QSysInfo::WV_DOS_based) ? "cmd.exe /c" : "command.com /c";
// Thnx kode54 :)
#else
szShell = "sh -c";
#endif
}
args = szShell.split(" ", QString::SkipEmptyParts);
args.append(m_pData->szCommandline);
}
m_pProcess = new QProcess(this);
if(m_pData->iFlags & KVI_KVS_PROCESSDESCRIPTOR_TRIGGERSTDOUT)
{
connect(m_pProcess, SIGNAL(readyReadStandardOutput()), this, SLOT(readStdout()));
}
else
{
m_pProcess->closeReadChannel(QProcess::StandardOutput);
}
if(m_pData->iFlags & KVI_KVS_PROCESSDESCRIPTOR_TRIGGERSTDERR)
{
connect(m_pProcess, SIGNAL(readyReadStandardError()), this, SLOT(readStderr()));
}
else
{
m_pProcess->closeReadChannel(QProcess::StandardError);
}
connect(m_pProcess, SIGNAL(finished(int)), this, SLOT(processExited(int)));
if(m_pData->iFlags & KVI_KVS_PROCESSDESCRIPTOR_TRIGGERSTARTED)
{
connect(m_pProcess, SIGNAL(started()), this, SLOT(processStarted()));
}
szcmd = args.takeFirst();
m_pProcess->start(szcmd, args);
if(m_pProcess->state() == QProcess::NotRunning)
{
return false;
}
if(m_pData->iMaxRunTime > 0)
{
m_pRunTimeTimer = new QTimer(this);
connect(m_pRunTimeTimer, SIGNAL(timeout()), this, SLOT(maxRunTimeExpired()));
m_pRunTimeTimer->start(m_pData->iMaxRunTime);
}
if(m_pData->iPingTimeout > 0)
{
m_pPingTimer = new QTimer(this);
connect(m_pPingTimer, SIGNAL(timeout()), this, SLOT(ping()));
m_pPingTimer->start(m_pData->iPingTimeout);
}
return true;
}
int main(int argc, char *argv[])
{
Q_INIT_RESOURCE(asebaqtabout);
QApplication app(argc, argv);
QCoreApplication::setOrganizationName(ASEBA_ORGANIZATION_NAME);
QCoreApplication::setOrganizationDomain(ASEBA_ORGANIZATION_DOMAIN);
app.setApplicationName("Playground");
QTextCodec::setCodecForTr(QTextCodec::codecForName("UTF-8"));
QTextCodec::setCodecForCStrings(QTextCodec::codecForName("UTF-8"));
// Translation support
QTranslator qtTranslator;
qtTranslator.load("qt_" + QLocale::system().name());
app.installTranslator(&qtTranslator);
QTranslator translator;
translator.load(QString(":/asebaplayground_") + QLocale::system().name());
app.installTranslator(&translator);
QTranslator aboutTranslator;
aboutTranslator.load(QString(":/qtabout_") + QLocale::system().name());
app.installTranslator(&aboutTranslator);
// create document
QDomDocument domDocument("aseba-playground");
QString sceneFileName;
// Get cmd line arguments
bool ask = true;
if (argc > 1)
{
sceneFileName = argv[1];
ask = false;
}
// Try to load xml config file
do
{
if (ask)
{
QString lastFileName = QSettings("EPFL-LSRO-Mobots", "Aseba Playground").value("last file").toString();
sceneFileName = QFileDialog::getOpenFileName(0, app.tr("Open Scenario"), lastFileName, app.tr("playground scenario (*.playground)"));
}
ask = true;
if (sceneFileName.isEmpty())
{
std::cerr << "You must specify a valid setup scenario on the command line or choose one in the file dialog." << std::endl;
exit(1);
}
QFile file(sceneFileName);
if (file.open(QIODevice::ReadOnly))
{
QString errorStr;
int errorLine, errorColumn;
if (!domDocument.setContent(&file, false, &errorStr, &errorLine, &errorColumn))
{
QMessageBox::information(0, "Aseba Playground",
app.tr("Parse error at file %1, line %2, column %3:\n%4")
.arg(sceneFileName)
.arg(errorLine)
.arg(errorColumn)
.arg(errorStr));
}
else
{
QSettings("EPFL-LSRO-Mobots", "Aseba Playground").setValue("last file", sceneFileName);
break;
}
}
}
while (true);
// Scan for colors
typedef QMap<QString, Enki::Color> ColorsMap;
ColorsMap colorsMap;
QDomElement colorE = domDocument.documentElement().firstChildElement("color");
while (!colorE.isNull())
{
colorsMap[colorE.attribute("name")] = Enki::Color(
colorE.attribute("r").toDouble(),
colorE.attribute("g").toDouble(),
colorE.attribute("b").toDouble()
);
colorE = colorE.nextSiblingElement ("color");
}
// Scan for areas
typedef QMap<QString, Enki::Polygon> AreasMap;
AreasMap areasMap;
QDomElement areaE = domDocument.documentElement().firstChildElement("area");
while (!areaE.isNull())
{
Enki::Polygon p;
QDomElement pointE = areaE.firstChildElement("point");
while (!pointE.isNull())
{
p.push_back(Enki::Point(
pointE.attribute("x").toDouble(),
pointE.attribute("y").toDouble()
));
pointE = pointE.nextSiblingElement ("point");
}
areasMap[areaE.attribute("name")] = p;
areaE = areaE.nextSiblingElement ("area");
}
// Create the world
QDomElement worldE = domDocument.documentElement().firstChildElement("world");
Enki::Color worldColor(Enki::Color::gray);
if (!colorsMap.contains(worldE.attribute("color")))
std::cerr << "Warning, world walls color " << worldE.attribute("color").toStdString() << " undefined\n";
else
worldColor = colorsMap[worldE.attribute("color")];
Enki::World::GroundTexture groundTexture;
if (worldE.hasAttribute("groundTexture"))
{
const QString groundTextureFileName(QFileInfo(sceneFileName).absolutePath() + QDir::separator() + worldE.attribute("groundTexture"));
QImage image(groundTextureFileName);
if (!image.isNull())
{
// flip vertically as y-coordinate is inverted in an image
image = image.mirrored();
// convert to a specific format and copy the underlying data to Enki
image = image.convertToFormat(QImage::Format_ARGB32);
groundTexture.width = image.width();
groundTexture.height = image.height();
const uint32_t* imageData(reinterpret_cast<const uint32_t*>(image.constBits()));
std::copy(imageData, imageData+image.width()*image.height(), std::back_inserter(groundTexture.data));
// Note: this works in little endian, in big endian data should be swapped
}
else
{
qDebug() << "Could not load ground texture file named" << groundTextureFileName;
}
}
Enki::World world(
worldE.attribute("w").toDouble(),
worldE.attribute("h").toDouble(),
worldColor,
groundTexture
);
// Create viewer
Enki::PlaygroundViewer viewer(&world, worldE.attribute("energyScoringSystemEnabled", "false").toLower() == "true");
if (Enki::simulatorEnvironment)
qDebug() << "A simulator environment already exists, replacing";
Enki::simulatorEnvironment.reset(new Enki::PlaygroundSimulatorEnvironment(sceneFileName, viewer));
// Zeroconf support to advertise targets
#ifdef ZEROCONF_SUPPORT
Aseba::QtZeroconf zeroconf;
#endif // ZEROCONF_SUPPORT
// Scan for camera
QDomElement cameraE = domDocument.documentElement().firstChildElement("camera");
if (!cameraE.isNull())
{
const double largestDim(qMax(world.h, world.w));
viewer.setCamera(
QPointF(
cameraE.attribute("x", QString::number(world.w / 2)).toDouble(),
cameraE.attribute("y", QString::number(0)).toDouble()
),
cameraE.attribute("altitude", QString::number(0.85 * largestDim)).toDouble(),
cameraE.attribute("yaw", QString::number(-M_PI/2)).toDouble(),
cameraE.attribute("pitch", QString::number((3*M_PI)/8)).toDouble()
);
}
// Scan for walls
QDomElement wallE = domDocument.documentElement().firstChildElement("wall");
while (!wallE.isNull())
{
Enki::PhysicalObject* wall = new Enki::PhysicalObject();
if (!colorsMap.contains(wallE.attribute("color")))
std::cerr << "Warning, color " << wallE.attribute("color").toStdString() << " undefined\n";
else
wall->setColor(colorsMap[wallE.attribute("color")]);
wall->pos.x = wallE.attribute("x").toDouble();
wall->pos.y = wallE.attribute("y").toDouble();
wall->setRectangular(
wallE.attribute("l1").toDouble(),
wallE.attribute("l2").toDouble(),
wallE.attribute("h").toDouble(),
!wallE.attribute("mass").isNull() ? wallE.attribute("mass").toDouble() : -1 // normally -1 because immobile
);
if (! wallE.attribute("angle").isNull())
wall->angle = wallE.attribute("angle").toDouble(); // radians
world.addObject(wall);
wallE = wallE.nextSiblingElement ("wall");
}
// Scan for cylinders
QDomElement cylinderE = domDocument.documentElement().firstChildElement("cylinder");
while (!cylinderE.isNull())
{
Enki::PhysicalObject* cylinder = new Enki::PhysicalObject();
if (!colorsMap.contains(cylinderE.attribute("color")))
std::cerr << "Warning, color " << cylinderE.attribute("color").toStdString() << " undefined\n";
else
cylinder->setColor(colorsMap[cylinderE.attribute("color")]);
cylinder->pos.x = cylinderE.attribute("x").toDouble();
cylinder->pos.y = cylinderE.attribute("y").toDouble();
cylinder->setCylindric(
cylinderE.attribute("r").toDouble(),
cylinderE.attribute("h").toDouble(),
!cylinderE.attribute("mass").isNull() ? cylinderE.attribute("mass").toDouble() : -1 // normally -1 because immobile
);
world.addObject(cylinder);
cylinderE = cylinderE.nextSiblingElement("cylinder");
}
// Scan for feeders
QDomElement feederE = domDocument.documentElement().firstChildElement("feeder");
while (!feederE.isNull())
{
Enki::EPuckFeeder* feeder = new Enki::EPuckFeeder;
feeder->pos.x = feederE.attribute("x").toDouble();
feeder->pos.y = feederE.attribute("y").toDouble();
world.addObject(feeder);
feederE = feederE.nextSiblingElement ("feeder");
}
// TODO: if needed, custom color to feeder
// Scan for doors
typedef QMap<QString, Enki::SlidingDoor*> DoorsMap;
DoorsMap doorsMap;
QDomElement doorE = domDocument.documentElement().firstChildElement("door");
while (!doorE.isNull())
{
Enki::SlidingDoor *door = new Enki::SlidingDoor(
Enki::Point(
doorE.attribute("closedX").toDouble(),
doorE.attribute("closedY").toDouble()
),
Enki::Point(
doorE.attribute("openedX").toDouble(),
doorE.attribute("openedY").toDouble()
),
Enki::Point(
doorE.attribute("l1").toDouble(),
doorE.attribute("l2").toDouble()
),
doorE.attribute("h").toDouble(),
doorE.attribute("moveDuration").toDouble()
);
if (!colorsMap.contains(doorE.attribute("color")))
std::cerr << "Warning, door color " << doorE.attribute("color").toStdString() << " undefined\n";
else
door->setColor(colorsMap[doorE.attribute("color")]);
doorsMap[doorE.attribute("name")] = door;
world.addObject(door);
doorE = doorE.nextSiblingElement ("door");
}
// Scan for activation, and link them with areas and doors
QDomElement activationE = domDocument.documentElement().firstChildElement("activation");
while (!activationE.isNull())
{
if (areasMap.find(activationE.attribute("area")) == areasMap.end())
{
std::cerr << "Warning, area " << activationE.attribute("area").toStdString() << " undefined\n";
activationE = activationE.nextSiblingElement ("activation");
continue;
}
if (doorsMap.find(activationE.attribute("door")) == doorsMap.end())
{
std::cerr << "Warning, door " << activationE.attribute("door").toStdString() << " undefined\n";
activationE = activationE.nextSiblingElement ("activation");
continue;
}
const Enki::Polygon& area = *areasMap.find(activationE.attribute("area"));
Enki::Door* door = *doorsMap.find(activationE.attribute("door"));
Enki::DoorButton* activation = new Enki::DoorButton(
Enki::Point(
activationE.attribute("x").toDouble(),
activationE.attribute("y").toDouble()
),
Enki::Point(
activationE.attribute("l1").toDouble(),
activationE.attribute("l2").toDouble()
),
area,
door
);
world.addObject(activation);
activationE = activationE.nextSiblingElement ("activation");
}
// load all robots in one loop
std::map<std::string, RobotType> robotTypes {
{ "thymio2", { "Thymio II", createRobotSingleVMNode<Enki::DashelAsebaThymio2> } },
{ "e-puck", { "E-Puck", createRobotSingleVMNode<Enki::DashelAsebaFeedableEPuck> } },
};
QDomElement robotE = domDocument.documentElement().firstChildElement("robot");
unsigned asebaServerCount(0);
while (!robotE.isNull())
{
const auto type(robotE.attribute("type", "thymio2"));
auto typeIt(robotTypes.find(type.toStdString()));
if (typeIt != robotTypes.end())
{
// retrieve informations
const auto& cppTypeName(typeIt->second.prettyName);
const auto qTypeName(QString::fromStdString(cppTypeName));
auto& countOfThisType(typeIt->second.number);
const auto qRobotNameRaw(robotE.attribute("name", QString("%1 %2").arg(qTypeName).arg(countOfThisType)));
const auto qRobotNameFull(QObject::tr("%2 on %3").arg(qRobotNameRaw).arg(QHostInfo::localHostName()));
const auto cppRobotName(qRobotNameFull.toStdString());
const unsigned port(robotE.attribute("port", QString("%1").arg(ASEBA_DEFAULT_PORT+asebaServerCount)).toUInt());
const int16_t nodeId(robotE.attribute("nodeId", "1").toInt());
// create
const auto& creator(typeIt->second.factory);
#ifdef ZEROCONF_SUPPORT
auto robot(creator(zeroconf, port, cppRobotName, cppTypeName, nodeId));
#else // ZEROCONF_SUPPORT
auto robot(creator(port, cppRobotName, cppTypeName, nodeId));
#endif // ZEROCONF_SUPPORT
asebaServerCount++;
countOfThisType++;
// setup in the world
robot->pos.x = robotE.attribute("x").toDouble();
robot->pos.y = robotE.attribute("y").toDouble();
robot->angle = robotE.attribute("angle").toDouble();
world.addObject(robot);
// log
viewer.log(app.tr("New robot %0 of type %1 on port %2").arg(qRobotNameRaw).arg(qTypeName).arg(port), Qt::white);
}
else
viewer.log("Error, unknown robot type " + type, Qt::red);
robotE = robotE.nextSiblingElement ("robot");
}
// Scan for external processes
QList<QProcess*> processes;
QDomElement procssE(domDocument.documentElement().firstChildElement("process"));
while (!procssE.isNull())
{
QString command(procssE.attribute("command"));
// create process
processes.push_back(new QProcess());
processes.back()->setProcessChannelMode(QProcess::MergedChannels);
// make sure it is killed when we close the window
QObject::connect(processes.back(), SIGNAL(started()), &viewer, SLOT(processStarted()));
QObject::connect(processes.back(), SIGNAL(error(QProcess::ProcessError)), &viewer, SLOT(processError(QProcess::ProcessError)));
QObject::connect(processes.back(), SIGNAL(readyReadStandardOutput()), &viewer, SLOT(processReadyRead()));
QObject::connect(processes.back(), SIGNAL(finished(int, QProcess::ExitStatus)), &viewer, SLOT(processFinished(int, QProcess::ExitStatus)));
// check whether it is a relative command
bool isRelative(false);
if (!command.isEmpty() && command[0] == ':')
{
isRelative = true;
command = command.mid(1);
}
// process the command into its components
QStringList args(command.split(" ", QString::SkipEmptyParts));
if (args.size() == 0)
{
viewer.log(app.tr("Missing program in command"), Qt::red);
}
else
{
const QString program(QDir::toNativeSeparators(args[0]));
args.pop_front();
if (isRelative)
processes.back()->start(QCoreApplication::applicationDirPath() + QDir::separator() + program, args, QIODevice::ReadOnly);
else
processes.back()->start(program, args, QIODevice::ReadOnly);
}
procssE = procssE.nextSiblingElement("process");
}
// Show and run
viewer.setWindowTitle(app.tr("Aseba Playground - Simulate your robots!"));
viewer.show();
// If D-Bus is used, register the viewer object
#ifdef HAVE_DBUS
new Enki::EnkiWorldInterface(&viewer);
QDBusConnection::sessionBus().registerObject("/world", &viewer);
QDBusConnection::sessionBus().registerService("ch.epfl.mobots.AsebaPlayground");
#endif // HAVE_DBUS
// Run the application
const int exitValue(app.exec());
// Stop and delete ongoing processes
foreach(QProcess*process,processes)
{
process->terminate();
if (!process->waitForFinished(1000))
process->kill();
delete process;
}
void ApplicationLauncher::bringToForeground()
{
emit bringToForegroundRequested(applicationPID());
emit processStarted();
}
bool RecipeDB::restore( const QString &file, QString *errMsg )
{
kDebug();
m_dumpFile = KFilterDev::deviceForFile(file,"application/x-gzip");
if ( m_dumpFile->open( QIODevice::ReadOnly ) ) {
m_dumpFile->setTextModeEnabled( true );
QString firstLine = QString::fromUtf8(m_dumpFile->readLine()).trimmed();
QString dbVersion = QString::fromUtf8(m_dumpFile->readLine()).trimmed();
dbVersion = dbVersion.right( dbVersion.length() - dbVersion.indexOf(":") - 2 );
if ( qRound(dbVersion.toDouble()*1e5) > qRound(latestDBVersion()*1e5) ) { //correct for float's imprecision
if ( errMsg ) *errMsg = i18n( "This backup was created with a newer version of Krecipes and cannot be restored." );
delete m_dumpFile;
return false;
}
KConfigGroup config = KGlobal::config()->group( "DBType" );
QString dbType = QString::fromUtf8(m_dumpFile->readLine()).trimmed();
dbType = dbType.right( dbType.length() - dbType.indexOf(":") - 2 );
if ( dbType.isEmpty() || !firstLine.startsWith("-- Generated for Krecipes") ) {
if ( errMsg ) *errMsg = i18n("This file is not a Krecipes backup file or has become corrupt.");
delete m_dumpFile;
return false;
}
else if ( dbType != config.readEntry("Type",QString()) ) {
if ( errMsg ) *errMsg = i18n("This backup was created using the \"%1\" backend. It can only be restored into a database using this backend." ,dbType);
delete m_dumpFile;
return false;
}
process = new KProcess;
QStringList command = restoreCommand();
kDebug()<<"Restoring backup using: "<<command[0];
*process << command;
QApplication::connect( process, SIGNAL(started()), this, SLOT(processStarted()) );
QApplication::connect( process, SIGNAL(error(QProcess::ProcessError)), this, SLOT(processError(QProcess::ProcessError)) );
QApplication::connect( process, SIGNAL(finished(int,QProcess::ExitStatus)), this, SLOT(processFinished(int,QProcess::ExitStatus)) );
m_processStarted = false;
m_processFinished = false;
m_processError = false;
m_operationHalted = false;
emit progressBegin(0,QString(),
QString("<center><b>%1</b></center>%2")
.arg(i18nc("@info:progress", "Restoring backup"))
.arg(i18n("Depending on the number of recipes and amount of data, this could take some time.")),50);
process->start();
m_localEventLoop = new QEventLoop;
m_localEventLoop->exec();
if ( m_processError && !m_processStarted ) {
if ( errMsg ) *errMsg = i18n("Unable to find or run the program '%1'. Either it is not installed on your system or it is not in $PATH.",
command.first());
delete m_localEventLoop;
delete process;
process = NULL;
delete m_dumpFile;
emit progressDone();
return false;
}
//We have to first wipe the database structure. Note that if we load a dump
//with from a previous version of Krecipes, the difference in structure
// wouldn't allow the data to be inserted. This remains forward-compatibity
//by loading the old schema and then porting it to the current version.
kDebug()<<"Wiping database...";
empty(); //the user had better be warned!
kDebug()<<"Database wiped.";
kDebug()<<"Reading backup file...";
m_timer = new QTimer;
QApplication::connect( m_timer, SIGNAL(timeout()), this, SLOT(processReadDump()) );
m_timer->start();
m_localEventLoop->exec();
delete m_timer;
kDebug()<<"Done.";
//Since the process will exit when all stdin has been sent and processed,
//just loop until the process is no longer running. If something goes
//wrong, the user can still hit cancel.
process->closeWriteChannel();
if (!m_processFinished && !m_processError) {
kDebug()<<"Waiting for process exit...";
m_localEventLoop->exec();
}
delete m_localEventLoop;
delete process;
process = NULL;
emit progressDone();
//Since we just loaded part of a file, the database won't be in a usable state.
//We'll wipe out the database structure and recreate it, leaving no data.
if ( haltOperation ) {
haltOperation=false;
empty();
checkIntegrity();
delete m_dumpFile;
if ( errMsg ) { *errMsg = i18n("Restore Failed"); }
return false;
}
m_dumpFile->close();
checkIntegrity();
}
ReplayGainScanner::ReplayGainScanner( Config* _config, Logger* _logger, bool showMainWindowButton, QWidget *parent, Qt::WFlags f )
: KDialog( parent, f ),
config( _config ),
logger( _logger )
{
setButtons( 0 );
setCaption( i18n("Replay Gain tool") );
setWindowIcon( KIcon("soundkonverter-replaygain") );
QWidget *widget = new QWidget( this );
setMainWidget( widget );
QGridLayout* grid = new QGridLayout( widget );
QHBoxLayout* filterBox = new QHBoxLayout();
grid->addLayout( filterBox, 0, 0 );
cAdd = new ComboButton( widget );
cAdd->insertItem( KIcon("folder"), i18n("Add folder...") );
cAdd->insertItem( KIcon("audio-x-generic"), i18n("Add files...") );
filterBox->addWidget( cAdd );
connect( cAdd, SIGNAL(clicked(int)), this, SLOT(addClicked(int)) );
filterBox->addStretch();
pShowMainWindow = new KPushButton( KIcon("soundkonverter"), i18n("Show soundKonverter main window"), widget );
pShowMainWindow->setVisible( showMainWindowButton );
filterBox->addWidget( pShowMainWindow );
connect( pShowMainWindow, SIGNAL(clicked()), this, SLOT(showMainWindowClicked()) );
fileList = new ReplayGainFileList( config, logger, widget );
grid->addWidget( fileList, 1, 0 );
connect( fileList, SIGNAL(processStarted()), this, SLOT(processStarted()) );
connect( fileList, SIGNAL(processStopped()), this, SLOT(processStopped()) );
QHBoxLayout* progressBox = new QHBoxLayout();
grid->addLayout( progressBox, 2, 0 );
progressIndicator = new ProgressIndicator( this );
progressBox->addWidget( progressIndicator );
connect( fileList, SIGNAL(timeChanged(float)), progressIndicator, SLOT(timeChanged(float)) );
connect( fileList, SIGNAL(finished(bool)), progressIndicator, SLOT(finished(bool)) );
connect( progressIndicator, SIGNAL(progressChanged(const QString&)), this, SLOT(progressChanged(const QString&)) );
QHBoxLayout* buttonBox = new QHBoxLayout();
grid->addLayout( buttonBox, 3, 0 );
pTagVisible = new KPushButton( KIcon("list-add"), i18n("Tag untagged"), widget );
pTagVisible->setToolTip( i18n("Calculate Replay Gain tags for all files in the file list without Replay Gain tags.") );
buttonBox->addWidget( pTagVisible );
connect( pTagVisible, SIGNAL(clicked()), this, SLOT(calcReplayGainClicked()) );
pRemoveTag = new KPushButton( KIcon("list-remove"), i18n("Untag tagged"), widget );
pRemoveTag->setToolTip( i18n("Remove the Replay Gain tags from all files in the file list.") );
buttonBox->addWidget( pRemoveTag );
connect( pRemoveTag, SIGNAL(clicked()), this, SLOT(removeReplayGainClicked()) );
pCancel = new KPushButton( KIcon("dialog-cancel"), i18n("Cancel"), widget );
pCancel->hide();
buttonBox->addWidget( pCancel );
connect( pCancel, SIGNAL(clicked()), this, SLOT(cancelClicked()) );
cForce = new QCheckBox( i18n("Force recalculation"), this );
cForce->setToolTip( i18n("Recalculate Replay Gain tags for files that already have Replay Gain tags set.") );
buttonBox->addWidget( cForce );
buttonBox->addStretch();
pClose = new KPushButton( KIcon("dialog-close"), i18n("Close"), widget );
pClose->setFocus();
buttonBox->addWidget( pClose );
connect( pClose, SIGNAL(clicked()), this, SLOT(closeClicked()) );
ReplayGainProcessor *replayGainProcessor = new ReplayGainProcessor( config, fileList, logger );
connect( fileList, SIGNAL(processItem(ReplayGainFileListItem*,ReplayGainPlugin::ApplyMode)), replayGainProcessor, SLOT(add(ReplayGainFileListItem*,ReplayGainPlugin::ApplyMode)) );
connect( fileList, SIGNAL(killItem(ReplayGainFileListItem*)), replayGainProcessor, SLOT(kill(ReplayGainFileListItem*)) );
connect( replayGainProcessor, SIGNAL(finished(ReplayGainFileListItem*,ReplayGainFileListItem::ReturnCode)), fileList, SLOT(itemFinished(ReplayGainFileListItem*,ReplayGainFileListItem::ReturnCode)) );
connect( replayGainProcessor, SIGNAL(finishedProcess(int,bool)), logger, SLOT(processCompleted(int,bool)) );
connect( replayGainProcessor, SIGNAL(updateTime(float)), progressIndicator, SLOT(update(float)) );
connect( replayGainProcessor, SIGNAL(timeFinished(float)), progressIndicator, SLOT(timeFinished(float)) );
setInitialSize( QSize(600,400) );
KSharedConfig::Ptr conf = KGlobal::config();
KConfigGroup group = conf->group( "ReplayGainTool" );
restoreDialogSize( group );
}
