bool Upload::adjustNewstuffFile(const Package &package)
{
if (m_xml.isNull()) {
QTemporaryFile tempFile(QDir::tempPath() + "/monav-maps-XXXXXX.xml");
tempFile.setAutoRemove(false);
tempFile.open();
QString monavFilename = tempFile.fileName();
tempFile.close();
QProcess wget;
QStringList const arguments = QStringList() << "http://filesmaster.kde.org/marble/newstuff/maps-monav.xml" << "-O" << monavFilename;
wget.start("wget", arguments);
wget.waitForFinished(1000 * 60 * 60 * 12); // wait up to 12 hours for download to complete
if (wget.exitStatus() != QProcess::NormalExit || wget.exitCode() != 0) {
qDebug() << "Failed to download newstuff file from filesmaster.kde.org";
changeStatus( package, "error", "Failed to sync newstuff file: " + wget.readAllStandardError());
return false;
}
QFile file(monavFilename);
if (!file.open(QFile::ReadOnly)) {
qDebug() << "Failed to open newstuff file" << monavFilename;
changeStatus( package, "error", "Failed to open newstuff file.");
return false;
}
if ( !m_xml.setContent( &file ) ) {
qDebug() << "Cannot parse newstuff xml file.";
changeStatus( package, "error", "Failed to parse newstuff .xml file.");
return false;
}
QFile::remove(monavFilename);
}
QDomElement root = m_xml.documentElement();
QDomNodeList regions = root.elementsByTagName( "stuff" );
for ( unsigned int i = 0; i < regions.length(); ++i ) {
QDomNode node = regions.item( i );
if (!node.namedItem("payload").isNull()) {
QUrl url = node.namedItem("payload").toElement().text();
QFileInfo fileInfo(url.path());
if (fileInfo.fileName() == package.file.fileName()) {
QString removeFile;
QDomNode dateNode = node.namedItem("releasedate");
if (!dateNode.isNull()) {
dateNode.removeChild(dateNode.firstChild());
dateNode.appendChild(m_xml.createTextNode(releaseDate()));
}
QDomNode versionNode = node.namedItem("version");
if (!versionNode.isNull()) {
double version = versionNode.toElement().text().toDouble();
versionNode.removeChild(versionNode.firstChild());
versionNode.appendChild(m_xml.createTextNode(QString::number(version+0.1, 'f', 1)));
}
QDomNode payloadNode = node.namedItem("payload");
payloadNode.removeChild(payloadNode.firstChild());
if (fileInfo.dir().dirName() != targetDir()) {
removeFile = QString("/home/marble/web/monav/%1/%2").arg(fileInfo.dir().dirName()).arg(package.file.fileName());
qDebug() << "Going to remove the old file " << removeFile;
}
QString payload = "http://files.kde.org/marble/monav/%1/%2";
payload = payload.arg(targetDir()).arg(package.file.fileName());
payloadNode.appendChild(m_xml.createTextNode(payload));
return removeFile.isEmpty() ? uploadNewstuff() : (uploadNewstuff() && deleteRemoteFile(removeFile));
}
}
}
QDomNode stuff = root.appendChild(m_xml.createElement("stuff"));
stuff.toElement().setAttribute("category", "marble/routing/monav");
QDomNode nameNode = stuff.appendChild(m_xml.createElement("name"));
nameNode.toElement().setAttribute("lang", "en");
QString name = "%1 / %2 (%3)";
if (package.region.country().isEmpty()) {
name = name.arg(package.region.continent()).arg(package.region.name());
name = name.arg(package.transport);
} else {
name = "%1 / %2 / %3 (%4)";
name = name.arg(package.region.continent()).arg(package.region.country());
name = name.arg(package.region.name()).arg(package.transport);
}
nameNode.appendChild(m_xml.createTextNode(name));
QDomNode authorNode = stuff.appendChild(m_xml.createElement("author"));
authorNode.appendChild(m_xml.createTextNode("Automatically created from map data assembled by the OpenStreetMap community"));
QDomNode licenseNode = stuff.appendChild(m_xml.createElement("license"));
licenseNode.appendChild(m_xml.createTextNode("Creative Commons by-SA 2.0"));
QDomNode summaryNode = stuff.appendChild(m_xml.createElement("summary"));
QString summary = "Requires KDE >= 4.6: Offline Routing in %1, %2";
summary = summary.arg(package.region.name()).arg(package.region.continent());
summaryNode.appendChild(m_xml.createTextNode(summary));
QDomNode versionNode = stuff.appendChild(m_xml.createElement("version"));
versionNode.appendChild(m_xml.createTextNode("0.1"));
QDomNode dateNode = stuff.appendChild(m_xml.createElement("releasedate"));
dateNode.appendChild(m_xml.createTextNode(releaseDate()));
QDomNode previewNode = stuff.appendChild(m_xml.createElement("preview"));
QString preview = "http://files.kde.org/marble/monav/previews/%1-preview.png";
preview = preview.arg(package.region.id());
previewNode.appendChild(m_xml.createTextNode(preview));
QDomNode payloadNode = stuff.appendChild(m_xml.createElement("payload"));
payloadNode.toElement().setAttribute("lang", "en");
QString payload = "http://files.kde.org/marble/monav/%1/%2";
payload = payload.arg(targetDir()).arg(package.file.fileName());
payloadNode.appendChild(m_xml.createTextNode(payload));
return uploadNewstuff();
}
bool SSHConnectionCLI::executeSCPFrom(const QString& source,
const QString& dest,
const QStringList& args,
QString* stdout_str, QString* stderr_str,
int* ec)
{
QProcess proc;
// Start with input args
QStringList fullArgs(args);
// Add port number
fullArgs << "-P" << QString::number(m_port);
// Add source
fullArgs << QString("%1%2%3:%4")
.arg(m_user)
.arg(m_user.isEmpty() ? "" : "@")
.arg(m_host)
.arg(source);
// Add destination
fullArgs << dest;
proc.start("scp", fullArgs);
int timeout_ms = 60000; // one minute
if (!proc.waitForStarted(timeout_ms)) {
qWarning() << QString("Failed to start scp command with args \"%1\" "
"after %2 seconds.")
.arg(fullArgs.join(","))
.arg(timeout_ms / 1000);
return false;
}
proc.closeWriteChannel();
if (!proc.waitForFinished(timeout_ms)) {
qWarning() << QString("scp command with args \"%1\" failed to finish "
"within %2 seconds.")
.arg(fullArgs.join(","))
.arg(timeout_ms / 1000);
return false;
}
if (proc.exitCode() != 0) {
qWarning() << QString("scp command with args \"%1\" failed with an exit "
"code of %2.")
.arg(fullArgs.join(","))
.arg(proc.exitCode())
<< "\nstdout:\n"
<< QString(proc.readAllStandardOutput()) << "\nstderr:\n"
<< QString(proc.readAllStandardError());
return false;
}
if (stdout_str != nullptr)
*stdout_str = QString(proc.readAllStandardOutput());
if (stderr_str != nullptr)
*stderr_str = QString(proc.readAllStandardError());
if (ec != nullptr)
*ec = proc.exitCode();
proc.close();
return true;
}
//------------------------------------------------------------------------------
// Name: on_buttonBox_accepted
// Desc:
//------------------------------------------------------------------------------
void DialogAssembler::on_buttonBox_accepted() {
static const QString mnemonic_regex = "([a-z][a-z0-9]*)";
static const QString register_regex = "((?:(?:e|r)?(?:ax|bx|cx|dx|bp|sp|si|di|ip))|(?:[abcd](?:l|h))|(?:sp|bp|si|di)l|(?:[cdefgs]s)|(?:x?mm[0-7])|r(?:8|9|(?:1[0-5]))[dwb]?)";
static const QString constant_regex = "((?:0[0-7]*)|(?:0x[0-9a-f]+)|(?:[1-9][0-9]*))";
static const QString pointer_regex = "(?:(t?byte|(?:xmm|[qdf]?)word)(?:\\s+ptr)?)?";
static const QString segment_regex = "([csdefg]s)";
static const QString expression_regex = QString("(%1\\s*(?:\\s+%2\\s*:\\s*)?\\[(\\s*(?:(?:%3(?:\\s*\\+\\s*%3(?:\\s*\\*\\s*%4)?)?(?:\\s*\\+\\s*%4)?)|(?:(?:%3(?:\\s*\\*\\s*%4)?)(?:\\s*\\+\\s*%4)?)|(?:%4)\\s*))\\])").arg(pointer_regex, segment_regex, register_regex, constant_regex);
static const QString operand_regex = QString("((?:%1)|(?:%2)|(?:%3))").arg(register_regex, constant_regex, expression_regex);
static const QString assembly_regex = QString("%1(?:\\s+%2\\s*(?:\\s*,\\s*%2\\s*(?:\\s*,\\s*%2\\s*)?)?)?").arg(mnemonic_regex, operand_regex);
// [ OFFSET]
// [ INDEX ]
// [ INDEX +OFFSET]
// [ INDEX*SCALE ]
// [ INDEX*SCALE+OFFSET]
// [BASE ]
// [BASE +OFFSET]
// [BASE+INDEX ]
// [BASE+INDEX +OFFSET]
// [BASE+INDEX*SCALE ]
// [BASE+INDEX*SCALE+OFFSET]
// -------------------------
// [((BASE(\+INDEX(\*SCALE)?)?(\+OFFSET)?)|((INDEX(\*SCALE)?)(\+OFFSET)?)|(OFFSET))]
const QString assembly = ui->assembly->currentText().trimmed();
QRegExp regex(assembly_regex, Qt::CaseInsensitive, QRegExp::RegExp2);
if(regex.exactMatch(assembly)) {
const QStringList list = regex.capturedTexts();
/*
[0] -> whole match
[1] -> mnemonic
[2] -> whole operand 1
[3] -> operand 1 (REGISTER)
[4] -> operand 1 (IMMEDIATE)
[5] -> operand 1 (EXPRESSION)
[6] -> operand 1 pointer (EXPRESSION)
[7] -> operand 1 segment (EXPRESSION)
[8] -> operand 1 internal expression (EXPRESSION)
[9] -> operand 1 base (EXPRESSION)
[10] -> operand 1 index (EXPRESSION)
[11] -> operand 1 scale (EXPRESSION)
[12] -> operand 1 displacement (EXPRESSION)
[13] -> operand 1 index (EXPRESSION) (version 2)
[14] -> operand 1 scale (EXPRESSION) (version 2)
[15] -> operand 1 displacement (EXPRESSION) (version 2)
[16] -> operand 1 displacement (EXPRESSION) (version 3)
[17] -> whole operand 2
[18] -> operand 2 (REGISTER)
[19] -> operand 2 (IMMEDIATE)
[20] -> operand 2 (EXPRESSION)
[21] -> operand 2 pointer (EXPRESSION)
[22] -> operand 2 segment (EXPRESSION)
[23] -> operand 2 internal expression (EXPRESSION)
[24] -> operand 2 base (EXPRESSION)
[25] -> operand 2 index (EXPRESSION)
[26] -> operand 2 scale (EXPRESSION)
[27] -> operand 2 displacement (EXPRESSION)
[28] -> operand 2 index (EXPRESSION) (version 2)
[29] -> operand 2 scale (EXPRESSION) (version 2)
[30] -> operand 2 displacement (EXPRESSION) (version 2)
[31] -> operand 2 displacement (EXPRESSION) (version 3)
[32] -> whole operand 3
[33] -> operand 3 (REGISTER)
[34] -> operand 3 (IMMEDIATE)
[35] -> operand 3 (EXPRESSION)
[36] -> operand 3 pointer (EXPRESSION)
[37] -> operand 3 segment (EXPRESSION)
[38] -> operand 3 internal expression (EXPRESSION)
[39] -> operand 3 base (EXPRESSION)
[40] -> operand 3 index (EXPRESSION)
[41] -> operand 3 scale (EXPRESSION)
[42] -> operand 3 displacement (EXPRESSION)
[43] -> operand 3 index (EXPRESSION) (version 2)
[44] -> operand 3 scale (EXPRESSION) (version 2)
[45] -> operand 3 displacement (EXPRESSION) (version 2)
[46] -> operand 3 displacement (EXPRESSION) (version 3)
*/
int operand_count = 0;
if(!list[2].isEmpty()) {
++operand_count;
}
if(!list[17].isEmpty()) {
++operand_count;
}
if(!list[32].isEmpty()) {
++operand_count;
}
QStringList operands;
for(int i = 0; i < operand_count; ++i) {
int offset = 15 * i;
if(!list[3 + offset].isEmpty()) {
operands << list[3 + offset];
} else if(!list[4 + offset].isEmpty()) {
operands << list[4 + offset];
} else if(!list[5 + offset].isEmpty()) {
if(!list[7 + offset].isEmpty()) {
operands << QString("%1 [%2:%3]").arg(list[6 + offset], list[7 + offset], list[8 + offset]);
} else {
operands << QString("%1 [%2]").arg(list[6 + offset], list[8 + offset]);
}
}
}
const QString nasm_syntax = list[1] + ' ' + operands.join(",");
QTemporaryFile source_file(QString("%1/edb_asm_temp_%2_XXXXXX.asm").arg(QDir::tempPath()).arg(getpid()));
if(!source_file.open()) {
QMessageBox::critical(this, tr("Error Creating File"), tr("Failed to create temporary source file."));
return;
}
QTemporaryFile output_file(QString("%1/edb_asm_temp_%2_XXXXXX.bin").arg(QDir::tempPath()).arg(getpid()));
if(!output_file.open()) {
QMessageBox::critical(this, tr("Error Creating File"), tr("Failed to create temporary object file."));
return;
}
QSettings settings;
const QString assembler = settings.value("Assembler/helper_application", "/usr/bin/yasm").toString();
const QFile file(assembler);
if(assembler.isEmpty() || !file.exists()) {
QMessageBox::warning(this, tr("Couldn't Find Assembler"), tr("Failed to locate your assembler, please specify one in the options."));
return;
}
const QFileInfo info(assembler);
QProcess process;
QStringList arguments;
QString program(assembler);
if(info.fileName() == "yasm") {
switch(edb::v1::debugger_core->cpu_type()) {
case edb::string_hash<'x', '8', '6'>::value:
source_file.write("[BITS 32]\n");
break;
case edb::string_hash<'x', '8', '6', '-', '6', '4'>::value:
source_file.write("[BITS 64]\n");
break;
default:
Q_ASSERT(0);
}
source_file.write(QString("[SECTION .text vstart=0x%1 valign=1]\n\n").arg(edb::v1::format_pointer(address_)).toLatin1());
source_file.write(nasm_syntax.toLatin1());
source_file.write("\n");
source_file.close();
arguments << "-o" << output_file.fileName();
arguments << "-f" << "bin";
arguments << source_file.fileName();
} else if(info.fileName() == "nasm") {
switch(edb::v1::debugger_core->cpu_type()) {
case edb::string_hash<'x', '8', '6'>::value:
source_file.write("[BITS 32]\n");
break;
case edb::string_hash<'x', '8', '6', '-', '6', '4'>::value:
source_file.write("[BITS 64]\n");
break;
default:
Q_ASSERT(0);
}
source_file.write(QString("ORG 0x%1\n\n").arg(edb::v1::format_pointer(address_)).toLatin1());
source_file.write(nasm_syntax.toLatin1());
source_file.write("\n");
source_file.close();
arguments << "-o" << output_file.fileName();
arguments << "-f" << "bin";
arguments << source_file.fileName();
}
process.start(program, arguments);
if(process.waitForFinished()) {
const int exit_code = process.exitCode();
if(exit_code != 0) {
QMessageBox::warning(this, tr("Error In Code"), process.readAllStandardError());
} else {
QByteArray bytes = output_file.readAll();
if(bytes.size() <= instruction_size_) {
if(ui->fillWithNOPs->isChecked()) {
// TODO: get system independent nop-code
edb::v1::modify_bytes(address_, instruction_size_, bytes, 0x90);
} else {
edb::v1::modify_bytes(address_, instruction_size_, bytes, 0x00);
}
} else {
if(ui->keepSize->isChecked()) {
QMessageBox::warning(this, tr("Error In Code"), tr("New instruction is too big to fit."));
} else {
edb::v1::modify_bytes(address_, bytes.size(), bytes, 0x00);
}
}
}
}
} else {
QMessageBox::warning(this, tr("Error In Code"), tr("Failed to assembly the given assemble code."));
}
}
void updateTOPPAS(const String& infile, const String& outfile)
{
Int this_instance = getIntOption_("instance");
INIUpdater updater;
String tmp_ini_file = File::getTempDirectory() + "/" + File::getUniqueName() + "_INIUpdater.ini";
tmp_files_.push_back(tmp_ini_file);
String path = File::getExecutablePath();
ParamXMLFile paramFile;
Param p;
paramFile.load(infile, p);
// get version of TOPPAS file
String version = "Unknown";
if (!p.exists("info:version"))
{
writeLog_("No OpenMS version information found in file " + infile + "! Assuming OpenMS 1.8 and below.");
version = "1.8.0";
}
else
{
version = p.getValue("info:version");
// TODO: return on newer version?!
}
Int vertices = p.getValue("info:num_vertices");
// update sections
writeDebug_("#Vertices: " + String(vertices), 1);
bool update_success = true;
for (Int v = 0; v < vertices; ++v)
{
String sec_inst = "vertices:" + String(v) + ":";
// check for default instance
if (!p.exists(sec_inst + "toppas_type"))
{
writeLog_("Update for file " + infile + " failed because the vertex #" + String(v) + " does not have a 'toppas_type' node. Check INI file for corruption!");
update_success = false;
break;
}
if (p.getValue(sec_inst + "toppas_type") != "tool") // not a tool (but input/output/merge node)
{
continue;
}
if (!p.exists(sec_inst + "tool_name"))
{
writeLog_("Update for file " + infile + " failed because the vertex #" + String(v) + " does not have a 'tool_name' node. Check INI file for corruption!");
update_success = false;
break;
}
String old_name = p.getValue(sec_inst + "tool_name");
String new_tool;
String ttype;
// find mapping to new tool (might be the same name)
if (p.exists(sec_inst + "tool_type")) ttype = p.getValue(sec_inst + "tool_type");
if (!updater.getNewToolName(old_name, ttype, new_tool))
{
String type_text = ((ttype == "") ? "" : " with type '" + ttype + "' ");
writeLog_("Update for file " + infile + " failed because the tool '" + old_name + "'" + type_text + "is unknown. TOPPAS file seems to be corrupted!");
update_success = false;
break;
}
// set new tool name
p.setValue(sec_inst + "tool_name", new_tool);
// delete TOPPAS type
if (new_tool != "GenericWrapper")
{
p.setValue(sec_inst + "tool_type", "");
}
// get defaults of new tool by calling it
QProcess pr;
QStringList arguments;
arguments << "-write_ini";
arguments << tmp_ini_file.toQString();
arguments << "-instance";
arguments << String(this_instance).toQString();
pr.start((path + "/" + new_tool).toQString(), arguments);
if (!pr.waitForFinished(-1))
{
writeLog_("Update for file " + infile + " failed because the tool '" + new_tool + "' returned with an error! Check if the tool works properly.");
update_success = false;
break;
}
// update defaults with old values
Param new_param;
paramFile.load(tmp_ini_file, new_param);
new_param = new_param.copy(new_tool + ":1", true);
Param old_param = p.copy(sec_inst + "parameters", true);
new_param.update(old_param);
// push back changes
p.remove(sec_inst + "parameters:");
p.insert(sec_inst + "parameters", new_param);
}
if (!update_success)
{
failed_.push_back(infile);
return;
}
paramFile.store(tmp_ini_file, p);
// update internal structure (e.g. edges format changed from 1.8 to 1.9)
int argc = 1;
const char* c = "IniUpdater";
const char** argv = &c;
QApplication app(argc, const_cast<char**>(argv), false);
String tmp_dir = File::getTempDirectory() + "/" + File::getUniqueName();
QDir d;
d.mkpath(tmp_dir.toQString());
TOPPASScene ts(0, tmp_dir.toQString(), false);
paramFile.store(tmp_ini_file, p);
ts.load(tmp_ini_file);
ts.store(tmp_ini_file);
paramFile.load(tmp_ini_file, p);
// STORE
if (outfile.empty()) // create a backup
{
QFileInfo fi(infile.toQString());
String new_name = String(fi.path()) + "/" + fi.completeBaseName() + "_v" + version + ".toppas";
QFile::rename(infile.toQString(), new_name.toQString());
// write new file
paramFile.store(infile, p);
}
else
{
paramFile.store(outfile, p);
}
}
int main(int argc, char **argv)
{
QApplication app(argc, argv);
App::initializeDependencies();
auto aboutData = App::getAboutData();
QCommandLineParser parser;
KAboutData::setApplicationData(aboutData);
parser.addVersionOption();
parser.addHelpOption();
aboutData.setupCommandLine(&parser);
parser.process(app);
aboutData.processCommandLine(&parser);
KSharedConfig::Ptr config = KSharedConfig::openConfig(QStringLiteral("zanshin-migratorrc"));
KConfigGroup group = config->group("Migrations");
if (!group.readEntry("Migrated021Projects", false)) {
std::cerr << "Migrating data from zanshin 0.2, please wait..." << std::endl;
QProcess proc;
proc.start(QStringLiteral("zanshin-migrator"));
proc.waitForFinished(-1);
if (proc.exitStatus() == QProcess::CrashExit) {
std::cerr << "Migrator crashed!" << std::endl;
} else if (proc.exitCode() == 0) {
std::cerr << "Migration done" << std::endl;
} else {
std::cerr << "Migration error, code" << proc.exitCode() << std::endl;
}
}
auto widget = new QWidget;
auto components = new Widgets::ApplicationComponents(widget);
components->setModel(Presentation::ApplicationModel::Ptr::create());
auto layout = new QVBoxLayout;
layout->setContentsMargins(0, 0, 0, 0);
layout->addWidget(components->pageView());
widget->setLayout(layout);
auto sourcesDock = new QDockWidget(QObject::tr("Sources"));
sourcesDock->setObjectName(QStringLiteral("sourcesDock"));
sourcesDock->setWidget(components->availableSourcesView());
auto pagesDock = new QDockWidget(QObject::tr("Pages"));
pagesDock->setObjectName(QStringLiteral("pagesDock"));
pagesDock->setWidget(components->availablePagesView());
auto editorDock = new QDockWidget(QObject::tr("Editor"));
editorDock->setObjectName(QStringLiteral("editorDock"));
editorDock->setWidget(components->editorView());
auto window = new KXmlGuiWindow;
window->setCentralWidget(widget);
window->addDockWidget(Qt::RightDockWidgetArea, editorDock);
window->addDockWidget(Qt::LeftDockWidgetArea, pagesDock);
window->addDockWidget(Qt::LeftDockWidgetArea, sourcesDock);
auto actions = components->globalActions();
actions.insert(QStringLiteral("dock_sources"), sourcesDock->toggleViewAction());
actions.insert(QStringLiteral("dock_pages"), pagesDock->toggleViewAction());
actions.insert(QStringLiteral("dock_editor"), editorDock->toggleViewAction());
auto ac = window->actionCollection();
ac->addAction(KStandardAction::Quit, window, SLOT(close()));
for (auto it = actions.constBegin(); it != actions.constEnd(); ++it) {
auto shortcut = it.value()->shortcut();
if (!shortcut.isEmpty()) {
ac->setDefaultShortcut(it.value(), shortcut);
}
ac->addAction(it.key(), it.value());
}
window->setupGUI(QSize(1024, 600),
KXmlGuiWindow::ToolBar
| KXmlGuiWindow::Keys
| KXmlGuiWindow::Save
| KXmlGuiWindow::Create);
window->show();
return app.exec();
}
void AndroidRunner::asyncStart()
{
QMutexLocker locker(&m_mutex);
forceStop();
if (m_useCppDebugger) {
// Remove pong file.
QProcess adb;
adb.start(m_adb, selector() << _("shell") << _("rm") << m_pongFile);
adb.waitForFinished();
}
QStringList args = selector();
args << _("shell") << _("am") << _("start") << _("-n") << m_intentName;
if (m_useCppDebugger) {
QProcess adb;
adb.start(m_adb, selector() << _("forward")
<< QString::fromLatin1("tcp:%1").arg(m_localGdbServerPort)
<< _("localfilesystem:") + m_gdbserverSocket);
if (!adb.waitForStarted()) {
emit remoteProcessFinished(tr("Failed to forward C++ debugging ports. Reason: %1.").arg(adb.errorString()));
return;
}
if (!adb.waitForFinished(5000)) {
emit remoteProcessFinished(tr("Failed to forward C++ debugging ports."));
return;
}
args << _("-e") << _("debug_ping") << _("true");
args << _("-e") << _("ping_file") << m_pingFile;
args << _("-e") << _("pong_file") << m_pongFile;
args << _("-e") << _("gdbserver_command") << m_gdbserverCommand;
args << _("-e") << _("gdbserver_socket") << m_gdbserverSocket;
}
if (m_useQmlDebugger || m_useQmlProfiler) {
// currently forward to same port on device and host
const QString port = QString::fromLatin1("tcp:%1").arg(m_qmlPort);
QProcess adb;
adb.start(m_adb, selector() << _("forward") << port << port);
if (!adb.waitForStarted()) {
emit remoteProcessFinished(tr("Failed to forward QML debugging ports. Reason: %1.").arg(adb.errorString()));
return;
}
if (!adb.waitForFinished()) {
emit remoteProcessFinished(tr("Failed to forward QML debugging ports."));
return;
}
args << _("-e") << _("qml_debug") << _("true");
args << _("-e") << _("qmljsdebugger") << QString::fromLatin1("port:%1,block").arg(m_qmlPort);
}
if (m_useLocalQtLibs) {
args << _("-e") << _("use_local_qt_libs") << _("true");
args << _("-e") << _("libs_prefix") << _("/data/local/tmp/qt/");
args << _("-e") << _("load_local_libs") << m_localLibs;
args << _("-e") << _("load_local_jars") << m_localJars;
if (!m_localJarsInitClasses.isEmpty())
args << _("-e") << _("static_init_classes") << m_localJarsInitClasses;
}
QProcess adb;
adb.start(m_adb, args);
if (!adb.waitForStarted()) {
emit remoteProcessFinished(tr("Failed to start the activity. Reason: %1.").arg(adb.errorString()));
return;
}
if (!adb.waitForFinished(5000)) {
adb.terminate();
emit remoteProcessFinished(tr("Unable to start '%1'.").arg(m_packageName));
return;
}
if (m_useCppDebugger) {
// Handling ping.
for (int i = 0; ; ++i) {
QTemporaryFile tmp(_("pingpong"));
tmp.open();
tmp.close();
QProcess process;
process.start(m_adb, selector() << _("pull") << m_pingFile << tmp.fileName());
process.waitForFinished();
QFile res(tmp.fileName());
const bool doBreak = res.size();
res.remove();
if (doBreak)
break;
if (i == 20) {
emit remoteProcessFinished(tr("Unable to start '%1'.").arg(m_packageName));
return;
}
qDebug() << "WAITING FOR " << tmp.fileName();
QThread::msleep(500);
}
}
m_tries = 0;
m_wasStarted = false;
QMetaObject::invokeMethod(&m_checkPIDTimer, "start");
}
void MetaEditorSupportPlugin::loadNewEditor(QString const &directoryName
, QPair<QString, QString> const &metamodelNames
, QString const &commandFirst
, QString const &commandSecond
, QString const &extension
, QString const &prefix
, QString const &buildConfiguration
)
{
int const progressBarWidth = 240;
int const progressBarHeight = 20;
QString const metamodelName = metamodelNames.first;
QString const normalizerMetamodelName = metamodelNames.second;
if ((commandFirst == "") || (commandSecond == "") || (extension == "")) {
QMessageBox::warning(mMainWindowInterface->windowWidget(), tr("error"), tr("please, fill compiler settings"));
return;
}
QString const normalizeDirName = metamodelName.at(0).toUpper() + metamodelName.mid(1);
QProgressBar * const progress = new QProgressBar(mMainWindowInterface->windowWidget());
progress->show();
QApplication::processEvents();
QRect const screenRect = qApp->desktop()->availableGeometry();
progress->move(screenRect.width() / 2 - progressBarWidth / 2, screenRect.height() / 2 - progressBarHeight / 2);
progress->setFixedWidth(progressBarWidth);
progress->setFixedHeight(progressBarHeight);
progress->setRange(0, 100);
progress->setValue(5);
const bool stateOfLoad = mMainWindowInterface->pluginLoaded(normalizeDirName);
if (!mMainWindowInterface->unloadPlugin(normalizeDirName)) {
progress->close();
delete progress;
return;
}
progress->setValue(20);
QStringList qmakeArgs;
qmakeArgs.append("CONFIG+=" + buildConfiguration);
qmakeArgs.append(metamodelName + ".pro");
QProcess builder;
builder.setWorkingDirectory(directoryName);
const QStringList environment = QProcess::systemEnvironment();
builder.setEnvironment(environment);
builder.start(commandFirst, qmakeArgs);
if ((builder.waitForFinished()) && (builder.exitCode() == 0)) {
progress->setValue(60);
builder.start(commandSecond);
if (builder.waitForFinished(60000) && (builder.exitCode() == 0)) {
progress->setValue(80);
if (stateOfLoad) {
QMessageBox::warning(mMainWindowInterface->windowWidget()
, tr("Attention!"), tr("Please restart QReal."));
progress->close();
delete progress;
return;
} else if (buildConfiguration == "debug") {
if (mMainWindowInterface->loadPlugin(prefix + metamodelName
+ "-d"+ "." + extension, normalizeDirName))
{
progress->setValue(100);
}
} else {
if (mMainWindowInterface->loadPlugin(prefix + metamodelName + "." + extension, normalizeDirName)) {
progress->setValue(100);
}
}
}
}
if (progress->value() == 20) {
QMessageBox::warning(mMainWindowInterface->windowWidget(), tr("error"), tr("cannot qmake new editor"));
} else if (progress->value() == 60) {
QMessageBox::warning(mMainWindowInterface->windowWidget(), tr("error"), tr("cannot make new editor"));
}
progress->setValue(100);
progress->close();
delete progress;
}
const AudioFileModel AnalyzeTask::analyzeFile(const QString &filePath, int *type)
{
*type = fileTypeNormal;
AudioFileModel audioFile(filePath);
QFile readTest(filePath);
if(!readTest.open(QIODevice::ReadOnly))
{
*type = fileTypeDenied;
return audioFile;
}
if(checkFile_CDDA(readTest))
{
*type = fileTypeCDDA;
return audioFile;
}
readTest.close();
bool skipNext = false;
QPair<quint32, quint32> id_val(UINT_MAX, UINT_MAX);
quint32 coverType = UINT_MAX;
QByteArray coverData;
QStringList params;
params << QString("--Inform=file://%1").arg(QDir::toNativeSeparators(m_templateFile));
params << QDir::toNativeSeparators(filePath);
QProcess process;
MUtils::init_process(process, QFileInfo(m_mediaInfoBin).absolutePath());
process.start(m_mediaInfoBin, params);
if(!process.waitForStarted())
{
qWarning("MediaInfo process failed to create!");
qWarning("Error message: \"%s\"\n", process.errorString().toLatin1().constData());
process.kill();
process.waitForFinished(-1);
return audioFile;
}
while(process.state() != QProcess::NotRunning)
{
if(*m_abortFlag)
{
process.kill();
qWarning("Process was aborted on user request!");
break;
}
if(!process.waitForReadyRead())
{
if(process.state() == QProcess::Running)
{
qWarning("MediaInfo time out. Killing process and skipping file!");
process.kill();
process.waitForFinished(-1);
return audioFile;
}
}
QByteArray data;
while(process.canReadLine())
{
QString line = QString::fromUtf8(process.readLine().constData()).simplified();
if(!line.isEmpty())
{
//qDebug("Line:%s", MUTILS_UTF8(line));
int index = line.indexOf('=');
if(index > 0)
{
QString key = line.left(index).trimmed();
QString val = line.mid(index+1).trimmed();
if(!key.isEmpty())
{
updateInfo(audioFile, skipNext, id_val, coverType, coverData, key, val);
}
}
}
}
}
if(audioFile.metaInfo().title().isEmpty())
{
QString baseName = QFileInfo(filePath).fileName();
int index = baseName.lastIndexOf(".");
if(index >= 0)
{
baseName = baseName.left(index);
}
baseName = baseName.replace("_", " ").simplified();
index = baseName.lastIndexOf(" - ");
if(index >= 0)
{
baseName = baseName.mid(index + 3).trimmed();
}
audioFile.metaInfo().setTitle(baseName);
}
process.waitForFinished();
if(process.state() != QProcess::NotRunning)
{
process.kill();
process.waitForFinished(-1);
}
if((coverType != UINT_MAX) && (!coverData.isEmpty()))
{
retrieveCover(audioFile, coverType, coverData);
}
if((audioFile.techInfo().audioType().compare("PCM", Qt::CaseInsensitive) == 0) && (audioFile.techInfo().audioProfile().compare("Float", Qt::CaseInsensitive) == 0))
{
if(audioFile.techInfo().audioBitdepth() == 32) audioFile.techInfo().setAudioBitdepth(AudioFileModel::BITDEPTH_IEEE_FLOAT32);
}
return audioFile;
}
bool AnalyzeTask::analyzeAvisynthFile(const QString &filePath, AudioFileModel &info)
{
QProcess process;
MUtils::init_process(process, QFileInfo(m_avs2wavBin).absolutePath());
process.start(m_avs2wavBin, QStringList() << QDir::toNativeSeparators(filePath) << "?");
if(!process.waitForStarted())
{
qWarning("AVS2WAV process failed to create!");
qWarning("Error message: \"%s\"\n", process.errorString().toLatin1().constData());
process.kill();
process.waitForFinished(-1);
return false;
}
bool bInfoHeaderFound = false;
while(process.state() != QProcess::NotRunning)
{
if(*m_abortFlag)
{
process.kill();
qWarning("Process was aborted on user request!");
break;
}
if(!process.waitForReadyRead())
{
if(process.state() == QProcess::Running)
{
qWarning("AVS2WAV time out. Killing process and skipping file!");
process.kill();
process.waitForFinished(-1);
return false;
}
}
QByteArray data;
while(process.canReadLine())
{
QString line = QString::fromUtf8(process.readLine().constData()).simplified();
if(!line.isEmpty())
{
int index = line.indexOf(':');
if(index > 0)
{
QString key = line.left(index).trimmed();
QString val = line.mid(index+1).trimmed();
if(bInfoHeaderFound && !key.isEmpty() && !val.isEmpty())
{
if(key.compare("TotalSeconds", Qt::CaseInsensitive) == 0)
{
bool ok = false;
unsigned int duration = val.toUInt(&ok);
if(ok) info.techInfo().setDuration(duration);
}
if(key.compare("SamplesPerSec", Qt::CaseInsensitive) == 0)
{
bool ok = false;
unsigned int samplerate = val.toUInt(&ok);
if(ok) info.techInfo().setAudioSamplerate (samplerate);
}
if(key.compare("Channels", Qt::CaseInsensitive) == 0)
{
bool ok = false;
unsigned int channels = val.toUInt(&ok);
if(ok) info.techInfo().setAudioChannels(channels);
}
if(key.compare("BitsPerSample", Qt::CaseInsensitive) == 0)
{
bool ok = false;
unsigned int bitdepth = val.toUInt(&ok);
if(ok) info.techInfo().setAudioBitdepth(bitdepth);
}
}
}
else
{
if(line.contains("[Audio Info]", Qt::CaseInsensitive))
{
info.techInfo().setAudioType("Avisynth");
info.techInfo().setContainerType("Avisynth");
bInfoHeaderFound = true;
}
}
}
}
}
process.waitForFinished();
if(process.state() != QProcess::NotRunning)
{
process.kill();
process.waitForFinished(-1);
}
//Check exit code
switch(process.exitCode())
{
case 0:
qDebug("Avisynth script was analyzed successfully.");
return true;
break;
case -5:
qWarning("It appears that Avisynth is not installed on the system!");
return false;
break;
default:
qWarning("Failed to open the Avisynth script, bad AVS file?");
return false;
break;
}
}
ExitCodes main_(int, const char**) override
{
String tmp_dir = QDir::toNativeSeparators((File::getTempDirectory() + "/" + File::getUniqueName() + "/").toQString()); // body for the tmp files
{
QDir d;
d.mkpath(tmp_dir.toQString());
}
String logfile(getStringOption_("log"));
String myrimatch_executable(getStringOption_("myrimatch_executable"));
//-------------------------------------------------------------
// get version of MyriMatch
//-------------------------------------------------------------
QProcess qp;
String myrimatch_version;
MyriMatchVersion myrimatch_version_i;
// we invoke myrimatch w/o arguments. that yields a return code != 0. but
// there is no other way for version 2.1 to get the version number
qp.start(myrimatch_executable.toQString(), QStringList(), QIODevice::ReadOnly); // does automatic escaping etc...
qp.waitForFinished();
String output(QString(qp.readAllStandardOutput()));
vector<String> lines;
vector<String> version_split;
output.split('\n', lines);
// the version number is expected to be in the second line
if (lines.size() < 2)
{
writeLog_("Warning: MyriMatch version output (" + output + ") not formatted as expected!");
return EXTERNAL_PROGRAM_ERROR;
}
// the version is expected to be something like:
// MyriMatch 2.1.111 (2011-12-27)
lines[1].split(' ', version_split);
if (version_split.size() == 3 && getVersion_(version_split[1], myrimatch_version_i))
{
myrimatch_version = version_split[1].removeWhitespaces();
writeDebug_("Setting MyriMatch version to " + myrimatch_version, 1);
}
else
{
writeLog_("Warning: MyriMatch version output (" + output + ") not formatted as expected!");
return EXTERNAL_PROGRAM_ERROR;
}
if (! ( (myrimatch_version_i.myrimatch_major == 2) && // major must be 2
(myrimatch_version_i.myrimatch_minor == 1 || myrimatch_version_i.myrimatch_minor == 2) // minor .1 or .2
))
{
writeLog_("Warning: unsupported MyriMatch version (" + myrimatch_version + "). Tested only for MyriMatch 2.1.x and 2.2.x."
"\nIf you encounter parameter errors, you can try the flag 'ignoreConfigErrors', but be aware that MyriMatch might be misconfigured.");
}
//-------------------------------------------------------------
// parsing parameters
//-------------------------------------------------------------
String inputfile_name = File::absolutePath(getStringOption_("in"));
String outputfile_name = getStringOption_("out");
String db_name = File::absolutePath(String(getStringOption_("database")));
// building parameter String
StringList parameters;
if (getFlag_("ignoreConfigErrors")) parameters << "-ignoreConfigErrors";
// Common Identification engine options
StringList static_mod_list;
StringList dynamic_mod_list;
translateModifications(static_mod_list, dynamic_mod_list);
if (!static_mod_list.empty())
parameters << "-StaticMods" << ListUtils::concatenate(static_mod_list, " ");
if (!dynamic_mod_list.empty())
parameters << "-DynamicMods" << ListUtils::concatenate(dynamic_mod_list, " ");
parameters << "-ProteinDatabase" << File::absolutePath(db_name);
if (getFlag_("precursor_mass_tolerance_avg"))
{
parameters << "-AvgPrecursorMzTolerance";
}
else
{
parameters << "-MonoPrecursorMzTolerance";
}
String precursor_mass_tolerance_unit = getStringOption_("precursor_mass_tolerance_unit") == "Da" ? " m/z" : " ppm";
parameters << String(getDoubleOption_("precursor_mass_tolerance")) + precursor_mass_tolerance_unit;
String fragment_mass_tolerance_unit = getStringOption_("fragment_mass_tolerance_unit");
if (fragment_mass_tolerance_unit == "Da")
{
fragment_mass_tolerance_unit = "m/z";
}
parameters << "-FragmentMzTolerance" << String(getDoubleOption_("fragment_mass_tolerance")) + " " + fragment_mass_tolerance_unit;
StringList slf = getStringList_("SpectrumListFilters");
if (slf.size() > 0)
{
if (myrimatch_version_i.myrimatch_minor <= 1)
{ // use quotes around the slf arguments (will be added automatically by Qt during call), i.e. "-SpectrumListFilters" "peakPicking false 2-"
parameters << "-SpectrumListFilters" << ListUtils::concatenate(slf, ";") << "";
}
else
{ // no quotes -- pass a single argument, i.e. "-SpectrumListFilters peakPicking false 2-"
parameters << "-SpectrumListFilters " + ListUtils::concatenate(slf, ";") << "";
}
}
//parameters << "-ThreadCountMultiplier" << String(getIntOption_("threads")); // MyriMatch does not recognise this, even though it's in the manual.
// MyriMatch specific parameters
parameters << "-NumChargeStates" << getIntOption_("NumChargeStates");
parameters << "-TicCutoffPercentage" << String(getDoubleOption_("TicCutoffPercentage"));
parameters << "-MaxDynamicMods" << getIntOption_("MaxDynamicMods");
parameters << "-MaxResultRank" << getIntOption_("MaxResultRank");
parameters << "-MinTerminiCleavages" << getIntOption_("MinTerminiCleavages");
parameters << "-MaxMissedCleavages" << getIntOption_("MaxMissedCleavages");
String cleavage_rule = getStringOption_("CleavageRules");
if (cleavage_rule.empty())
{
cleavage_rule = "Trypsin/P";
}
parameters << "-CleavageRules" << cleavage_rule;
// advanced parameters
parameters << "-MinPeptideMass" << getDoubleOption_("MinPeptideMass");
parameters << "-MaxPeptideMass" << getDoubleOption_("MaxPeptideMass");
parameters << "-MinPeptideLength" << getIntOption_("MinPeptideLength");
parameters << "-MaxPeptideLength" << getIntOption_("MaxPeptideLength");
parameters << "-NumIntensityClasses" << getIntOption_("NumIntensityClasses");
parameters << "-ClassSizeMultiplier" << getDoubleOption_("ClassSizeMultiplier");
parameters << "-MonoisotopeAdjustmentSet" << getStringOption_("MonoisotopeAdjustmentSet");
parameters << "-cpus" << getIntOption_("threads");
// Constant parameters
// DecoyPrefix worked only when set through the config file
String cfg_file = tmp_dir + "myrimatch.cfg";
ofstream f(cfg_file.c_str());
f << "DecoyPrefix=\"\"\n";
f.close();
parameters << "-cfg" << cfg_file;
// path to input file must be the last parameter
parameters << inputfile_name;
//-------------------------------------------------------------
// calculations
//-------------------------------------------------------------
QStringList qparam;
writeDebug_("MyriMatch arguments:", 1);
writeDebug_(String("\"") + ListUtils::concatenate(parameters, "\" \"") + "\"", 1);
for (Size i = 0; i < parameters.size(); ++i)
{
qparam << parameters[i].toQString();
}
QProcess process;
// Bad style, because it breaks relative paths?
process.setWorkingDirectory(tmp_dir.toQString());
process.start(myrimatch_executable.toQString(), qparam, QIODevice::ReadOnly);
bool success = process.waitForFinished(-1);
String myri_msg(QString(process.readAllStandardOutput()));
String myri_err(QString(process.readAllStandardError()));
writeDebug_(myri_msg, 1);
writeDebug_(myri_err, 0);
if (!success || process.exitStatus() != 0 || process.exitCode() != 0)
{
writeLog_("Error: MyriMatch problem! (Details can be seen in the logfile: \"" + logfile + "\")");
writeLog_("Note: This message can also be triggered if you run out of space in your tmp directory");
return EXTERNAL_PROGRAM_ERROR;
}
//-------------------------------------------------------------
// reading MyriMatch output
//-------------------------------------------------------------
writeDebug_("Reading output of MyriMatch", 5);
String exp_name = File::basename(inputfile_name);
String pep_file = tmp_dir + File::removeExtension(exp_name) + ".pepXML";
vector<ProteinIdentification> protein_identifications;
vector<PeptideIdentification> peptide_identifications;
PeakMap exp;
if (File::exists(pep_file))
{
MzMLFile fh;
fh.load(inputfile_name, exp);
SpectrumMetaDataLookup lookup;
lookup.readSpectra(exp.getSpectra());
PepXMLFile().load(pep_file, protein_identifications,
peptide_identifications, exp_name, lookup);
}
else
{
writeLog_("Error: MyriMatch problem! No pepXML output file (expected as '" + pep_file + "') was generated by MyriMatch.");
writeLog_("Note: This message can be triggered if no MS2 spectra were found or no identifications were made.");
writeLog_(" Myrimatch expects MS2 spectra in mzML files to contain the MSn tag. MSSpectrum with MS level 2 is not sufficient. You can use FileConverter to create such an mzML file by converting from mzML --> mzXML --> mzML.");
return EXTERNAL_PROGRAM_ERROR;
}
if (debug_level_ == 0)
{
QFile(pep_file.toQString()).remove();
QFile(cfg_file.toQString()).remove();
}
else
{
writeDebug_(String("Not removing '") + pep_file + "' for debugging purposes. Please delete manually!", 1);
writeDebug_(String("Not removing '") + cfg_file + "' for debugging purposes. Please delete manually!", 1);
}
//-------------------------------------------------------------
// writing results
//-------------------------------------------------------------
ProteinIdentification::SearchParameters search_parameters;
search_parameters.db = getStringOption_("database");
ProteinIdentification::PeakMassType mass_type = getFlag_("precursor_mass_tolerance_avg") == true ? ProteinIdentification::AVERAGE : ProteinIdentification::MONOISOTOPIC;
search_parameters.mass_type = mass_type;
search_parameters.fixed_modifications = getStringList_("fixed_modifications");
search_parameters.variable_modifications = getStringList_("variable_modifications");
search_parameters.missed_cleavages = getIntOption_("MaxMissedCleavages");
search_parameters.fragment_mass_tolerance = getDoubleOption_("fragment_mass_tolerance");
search_parameters.precursor_mass_tolerance = getDoubleOption_("precursor_mass_tolerance");
search_parameters.precursor_mass_tolerance_ppm = getStringOption_("precursor_mass_tolerance_unit") == "ppm" ? true : false;
search_parameters.fragment_mass_tolerance_ppm = getStringOption_("fragment_mass_tolerance_unit") == "ppm" ? true : false;
protein_identifications[0].setSearchParameters(search_parameters);
protein_identifications[0].setSearchEngineVersion(myrimatch_version);
protein_identifications[0].setSearchEngine("MyriMatch");
if (!protein_identifications.empty())
{
StringList ms_runs;
exp.getPrimaryMSRunPath(ms_runs);
protein_identifications[0].setPrimaryMSRunPath(ms_runs);
}
IdXMLFile().store(outputfile_name, protein_identifications, peptide_identifications);
return EXECUTION_OK;
}
bool CommandLineExporter::executeCommand
(
const QString& command,
const QString& inputFilePath,
const QString& textInput,
const QString& outputFilePath,
QString& stdoutOutput,
QString& stderrOutput
)
{
QProcess process;
process.setReadChannel(QProcess::StandardOutput);
QString expandedCommand = command + QString(" ");
if (!outputFilePath.isNull() && !outputFilePath.isEmpty())
{
// Redirect stdout to the output file path if the path variable wasn't
// set in the command string.
//
if (!expandedCommand.contains(OUTPUT_FILE_PATH_VAR))
{
process.setStandardOutputFile(outputFilePath);
}
else
{
// Surround file path with quotes in case there are spaces in the
// path.
//
QString outputFilePathWithQuotes = QString('\"') +
outputFilePath + '\"';
expandedCommand.replace(OUTPUT_FILE_PATH_VAR, outputFilePathWithQuotes);
}
}
if
(
this->getSmartTypographyEnabled() &&
!this->smartTypographyOnArgument.isNull()
)
{
expandedCommand.replace
(
SMART_TYPOGRAPHY_ARG,
smartTypographyOnArgument
);
}
else if
(
!this->getSmartTypographyEnabled() &&
!this->smartTypographyOffArgument.isNull()
)
{
expandedCommand.replace
(
SMART_TYPOGRAPHY_ARG,
smartTypographyOffArgument
);
}
if (!inputFilePath.isNull() && !inputFilePath.isEmpty())
{
process.setWorkingDirectory(QFileInfo(inputFilePath).dir().path());
}
process.start(expandedCommand);
if (!process.waitForStarted())
{
return false;
}
else
{
if (!textInput.isNull() && !textInput.isEmpty())
{
process.write(textInput.toUtf8());
process.closeWriteChannel();
}
if (!process.waitForFinished())
{
return false;
}
else
{
stdoutOutput = QString::fromUtf8(process.readAllStandardOutput().data());
stderrOutput = QString::fromUtf8(process.readAllStandardError().data());
}
}
return true;
}
void StelLogger::init(const QString& logFilePath)
{
logFile.setFileName(logFilePath);
if (logFile.open(QIODevice::WriteOnly | QIODevice::Truncate | QIODevice::Text | QIODevice::Unbuffered))
qInstallMessageHandler(StelLogger::debugLogHandler);
// write timestamp
writeLog(QString("%1").arg(QDateTime::currentDateTime().toString(Qt::ISODate)));
// write info about operating system
writeLog(StelUtils::getOperatingSystemInfo());
// write compiler version
#if defined __GNUC__ && !defined __clang__
#ifdef __MINGW32__
#define COMPILER "MinGW GCC"
#else
#define COMPILER "GCC"
#endif
writeLog(QString("Compiled using %1 %2.%3.%4").arg(COMPILER).arg(__GNUC__).arg(__GNUC_MINOR__).arg(__GNUC_PATCHLEVEL__));
#elif defined __clang__
writeLog(QString("Compiled using %1 %2.%3.%4").arg("Clang").arg(__clang_major__).arg(__clang_minor__).arg(__clang_patchlevel__));
#elif defined _MSC_VER
writeLog(QString("Compiled using %1").arg(getMsvcVersionString(_MSC_VER)));
#else
writeLog("Unknown compiler");
#endif
// write Qt version
writeLog(QString("Qt runtime version: %1").arg(qVersion()));
writeLog(QString("Qt compilation version: %1").arg(QT_VERSION_STR));
// write addressing mode
#if defined(__LP64__) || defined(_WIN64)
writeLog("Addressing mode: 64-bit");
#else
writeLog("Addressing mode: 32-bit");
#endif
// write memory and CPU info
#ifdef Q_OS_LINUX
#ifndef BUILD_FOR_MAEMO
QFile infoFile("/proc/meminfo");
if(!infoFile.open(QIODevice::ReadOnly | QIODevice::Text))
writeLog("Could not get memory info.");
else
{
while(!infoFile.peek(1).isEmpty())
{
QString line = infoFile.readLine();
line.chop(1);
if (line.startsWith("Mem") || line.startsWith("SwapTotal"))
writeLog(line);
}
infoFile.close();
}
infoFile.setFileName("/proc/cpuinfo");
if (!infoFile.open(QIODevice::ReadOnly | QIODevice::Text))
writeLog("Could not get CPU info.");
else
{
while(!infoFile.peek(1).isEmpty())
{
QString line = infoFile.readLine();
line.chop(1);
if(line.startsWith("model name") || line.startsWith("cpu MHz"))
writeLog(line);
}
infoFile.close();
}
QProcess lspci;
lspci.start("lspci -v", QIODevice::ReadOnly);
lspci.waitForFinished(300);
const QString pciData(lspci.readAll());
QStringList pciLines = pciData.split('\n', QString::SkipEmptyParts);
for (int i = 0; i<pciLines.size(); i++)
{
if(pciLines.at(i).contains("VGA compatible controller"))
{
writeLog(pciLines.at(i));
i++;
while(i < pciLines.size() && pciLines.at(i).startsWith('\t'))
{
if(pciLines.at(i).contains("Kernel driver in use"))
writeLog(pciLines.at(i).trimmed());
else if(pciLines.at(i).contains("Kernel modules"))
writeLog(pciLines.at(i).trimmed());
i++;
}
}
}
#endif
// Aargh Windows API
#elif defined Q_OS_WIN
// Hopefully doesn't throw a linker error on earlier systems. Not like
// I'm gonna test it or anything.
if (QSysInfo::WindowsVersion >= QSysInfo::WV_XP)
{
MEMORYSTATUSEX statex;
statex.dwLength = sizeof (statex);
GlobalMemoryStatusEx(&statex);
writeLog(QString("Total physical memory: %1 MB").arg(statex.ullTotalPhys/(1024<<10)));
writeLog(QString("Available physical memory: %1 MB").arg(statex.ullAvailPhys/(1024<<10)));
writeLog(QString("Physical memory in use: %1%").arg(statex.dwMemoryLoad));
#ifndef _WIN64
// This always reports about 8TB on Win64, not really useful to show.
writeLog(QString("Total virtual memory: %1 MB").arg(statex.ullTotalVirtual/(1024<<10)));
writeLog(QString("Available virtual memory: %1 MB").arg(statex.ullAvailVirtual/(1024<<10)));
#endif
}
else
writeLog("Windows version too old to get memory info.");
HKEY hKey = NULL;
DWORD dwType = REG_DWORD;
DWORD numVal = 0;
DWORD dwSize = sizeof(numVal);
// iterate over the processors listed in the registry
QString procKey = "Hardware\\Description\\System\\CentralProcessor";
LONG lRet = ERROR_SUCCESS;
int i;
for(i = 0; lRet == ERROR_SUCCESS; i++)
{
lRet = RegOpenKeyExA(HKEY_LOCAL_MACHINE,
qPrintable(QString("%1\\%2").arg(procKey).arg(i)),
0, KEY_QUERY_VALUE, &hKey);
if(lRet == ERROR_SUCCESS)
{
if(RegQueryValueExA(hKey, "~MHz", NULL, &dwType, (LPBYTE)&numVal, &dwSize) == ERROR_SUCCESS)
writeLog(QString("Processor speed: %1 MHz").arg(numVal));
else
writeLog("Could not get processor speed.");
}
// can you believe this trash?
dwType = REG_SZ;
char nameStr[512];
DWORD nameSize = sizeof(nameStr);
if (lRet == ERROR_SUCCESS)
{
if (RegQueryValueExA(hKey, "ProcessorNameString", NULL, &dwType, (LPBYTE)&nameStr, &nameSize) == ERROR_SUCCESS)
writeLog(QString("Processor name: %1").arg(nameStr));
else
writeLog("Could not get processor name.");
}
RegCloseKey(hKey);
}
if(i == 0)
writeLog("Could not get processor info.");
#elif defined Q_OS_MAC
QProcess systemProfiler;
systemProfiler.start("/usr/sbin/system_profiler -detailLevel mini SPHardwareDataType SPDisplaysDataType");
systemProfiler.waitForStarted();
systemProfiler.waitForFinished();
const QString systemData(systemProfiler.readAllStandardOutput());
QStringList systemLines = systemData.split('\n', QString::SkipEmptyParts);
for (int i = 0; i<systemLines.size(); i++)
{
if(systemLines.at(i).contains("Model"))
{
writeLog(systemLines.at(i).trimmed());
}
if(systemLines.at(i).contains("Processor"))
{
writeLog(systemLines.at(i).trimmed());
}
if(systemLines.at(i).contains("Memory"))
{
writeLog(systemLines.at(i).trimmed());
}
if(systemLines.at(i).contains("VRAM"))
{
writeLog(systemLines.at(i).trimmed());
}
}
#elif defined Q_OS_BSD4
QProcess dmesg;
dmesg.start("/sbin/dmesg", QIODevice::ReadOnly);
dmesg.waitForStarted();
dmesg.waitForFinished();
const QString dmesgData(dmesg.readAll());
QStringList dmesgLines = dmesgData.split('\n', QString::SkipEmptyParts);
for (int i = 0; i<dmesgLines.size(); i++)
{
if (dmesgLines.at(i).contains("memory"))
{
writeLog(dmesgLines.at(i).trimmed());
}
if (dmesgLines.at(i).contains("CPU"))
{
writeLog(dmesgLines.at(i).trimmed());
}
if (dmesgLines.at(i).contains("VGA"))
{
writeLog(dmesgLines.at(i).trimmed());
}
}
#endif
}
/**************************************************************************************************
* inicia o pserve para receber as imagens e plota na ui
**************************************************************************************************/
void MainWindow::start_pserve()
{
contagem=0;
pixeis_lidos=0;
QProcess *myProcess = new QProcess;
QStringList arguments_pserve;
process_pserve = Current_Path+"/pserve";
arguments_pserve<<Count_L<<NImage<<Save_Path;
myProcess->setProcessChannelMode(QProcess::MergedChannels);
myProcess->start(process_pserve,arguments_pserve);
myProcess->waitForStarted();
QPixmap pixmap;
float contagem_anterior;
/**************************************************************************************************
* le uma imagem
**************************************************************************************************/
if(NImage.toInt()==1)
{
if(Count_L.toInt()==0) // 1 bit
{
contagem=0;
pixeis_lidos=0;
myProcess->waitForFinished((Time.toFloat()*1000)+100);
QImage image(256,256,QImage::Format_Indexed8);
if(image.load(Save_Path+"1.ppm","pbm")==true)
{
image.invertPixels();
for(int a=0;a<=255;a++)
{
for(int b=0;b<=255;b++)
{
contagem=contagem+(1-image.pixelIndex(b,a));
pixeis_lidos=contagem;
}
}
}
else
{
image.fill(Qt::black);
ui->textBrowser->append("Error Reading Image!!!");
}
pixmap = QPixmap::fromImage(image,Qt::ColorOnly);
}
else if(Count_L.toInt()==1) // 12 bits
{
contagem=0;
pixeis_lidos=0;
myProcess->waitForFinished((Time.toFloat()*1000)+1000);
QImage image(256,256,QImage::Format_RGB16);
QByteArray teste;
QFile filestr(Save_Path+"1.ppm");
if(filestr.open(QIODevice::ReadOnly)==true)
{
teste=filestr.readAll();
QString colorstr(teste);
QStringList colors = colorstr.split(QRegExp("\\s+"));
colors.removeLast();
colors.removeFirst();
colors.removeFirst();
colors.removeFirst();
colors.removeFirst();
QVector<QRgb> colortable;
Lookup_Tables ctable;
colortable=ctable.colorPalete1280();
image.setColorTable(colortable);
int cont=0;
for(int a=0;a<=255;a++)
{
for(int b=0;b<=255;b++)
{
if(qCeil(colors.at(cont).toInt()/3.2)>=1280)
{
image.setPixel(b,a, image.colorTable().at(1279));
}
else
{
image.setPixel(b,a, image.colorTable().at(qCeil(colors.at(cont).toUInt()/3.2)));
}
contagem_anterior=contagem;
contagem=contagem+colors.at(cont).toFloat();
cont++;
if(contagem_anterior!=contagem)
{
pixeis_lidos++;
}
}
}
}
else
{
image.fill(Qt::black);
ui->textBrowser->append("Error Reading Image!!!");
}
pixmap = QPixmap::fromImage(image,Qt::ColorOnly);
}
else if(Count_L.toInt()==2) // 6 bits
{
contagem=0;
pixeis_lidos=0;
myProcess->waitForFinished((Time.toFloat()*1000)+500);
QImage image(256,256,QImage::Format_Indexed8);
if(image.load(Save_Path+"1.ppm","pbm")==true)
{
QVector<QRgb> colortable;
Lookup_Tables ctable;
colortable=ctable.colorPalete64();
image.setColorTable(colortable);
}
else
{
image.fill(Qt::black);
ui->textBrowser->append("Error Reading Image!!!");
}
pixmap = QPixmap::fromImage(image,Qt::ColorOnly);
for(int a=0;a<=255;a++)
{
for(int b=0;b<=255;b++)
{
contagem_anterior=contagem;
contagem=contagem+image.pixelIndex(b,a);
if(contagem_anterior!=contagem)
{
pixeis_lidos++;
}
}
}
}
else if(Count_L.toInt()==3) // 24 bits
{
contagem=0;
pixeis_lidos=0;
myProcess->waitForFinished((Time.toFloat()*1000)+1500);
QImage image(256,256,QImage::Format_RGB32);
QByteArray teste;
QFile filestr(Save_Path+"1.ppm");
if(filestr.open(QIODevice::ReadOnly)==true)
{
teste=filestr.readAll();
QString colorstr(teste);
QStringList colors = colorstr.split(QRegExp("\\s+"));
colors.removeLast();
colors.removeFirst();
colors.removeFirst();
colors.removeFirst();
colors.removeFirst();
QVector<QRgb> colortable;
Lookup_Tables ctable;
colortable=ctable.colorPalete1280();
image.setColorTable(colortable);
int cont=0;
for(int a=0;a<=255;a++)
{
for(int b=0;b<=255;b++)
{
if(qCeil(colors.at(cont).toInt()/100)>=1536)
{
image.setPixel(b,a, image.colorTable().at(1535));
}
else
{
image.setPixel(b,a, image.colorTable().at(qCeil(colors.at(cont).toUInt()/100)));
}
contagem_anterior=contagem;
contagem=contagem+colors.at(cont).toFloat();
cont++;
if(contagem_anterior!=contagem)
{
pixeis_lidos++;
}
}
}
}
else
{
image.fill(Qt::black);
ui->textBrowser->append("Error Reading Image!!!");
}
pixmap = QPixmap::fromImage(image,Qt::ColorOnly);
}
pixmap=pixmap.scaled(512,512);
scene= new QGraphicsScene(this);
scene->addPixmap(pixmap);
ui->Plot_Window->setScene(scene);
QByteArray text_response=myProcess->readAll();
QString mystr(text_response);
ui->textBrowser->setText(mystr);
ui->textBrowser->append("Total Count = "+QString::number(contagem));
ui->textBrowser->append("Pixel Read = "+QString::number(pixeis_lidos));
}
/**************************************************************************************************
* le +1 imagem
**************************************************************************************************/
else
{
Save_Dir.setFilter(QDir::Files | QDir::Hidden | QDir::NoSymLinks);
Save_Dir.setSorting(QDir::Time);
QString lee(Image_Name);
int cont =0;
lee.append(QString::number(cont));
for(int a=0;a<=(NImage.toInt()-1);a++)
{
if(Count_L.toInt()==0) // 1 bit
{
if(a==(NImage.toInt()-1))
{
myProcess->waitForFinished(NImage.toInt()*((Gap.toInt()*1000)+(Time.toFloat()*1000)+300));
}
else if(a==0)
{
QThread::msleep((Time.toFloat()*1000)+300);
}
else
{
QThread::msleep((Gap.toInt()*1000)+(Time.toFloat()*1000)+300);
}
cont++;
lee.replace(lee.size()-1,1,QString::number(cont));
QImage image(256,256,QImage::Format_Indexed8);
image.load(Save_Dir.absolutePath()+"/"+lee+".ppm","pbm");
image.invertPixels();
pixmap = QPixmap::fromImage(image,Qt::ColorOnly);
pixmap=pixmap.scaled(512,512);
scene= new QGraphicsScene(this);
scene->addPixmap(pixmap);
scene->update();
ui->Plot_Window->setScene(scene);
ui->Plot_Window->update();
QByteArray text_response=myProcess->readAll();
QString mystr(text_response);
ui->textBrowser->setText(mystr);
ui->textBrowser->update();
QCoreApplication::processEvents(QEventLoop::AllEvents);
}
else if(Count_L.toInt()==1) // 12 bits
{
if(a==(NImage.toInt()-1))
{
myProcess->waitForFinished(NImage.toInt()*((Gap.toInt()*1000)+(Time.toFloat()*1000)+1000));
}
else if(a==0)
{
QThread::msleep((Time.toFloat()*1000)+1000);
}
else
{
QThread::msleep((Gap.toInt()*1000)+(Time.toFloat()*1000)+1000);
}
QByteArray text_response=myProcess->readAll();
QString mystr(text_response);
ui->textBrowser->setText(mystr);
cont++;
lee.replace(lee.size()-1,1,QString::number(cont));
QImage image(256,256,QImage::Format_RGB16);
QByteArray teste;
QFile filestr(Save_Dir.absolutePath()+"/"+lee+".ppm");
filestr.open(QIODevice::ReadOnly);
teste=filestr.readAll();
QString colorstr(teste);
QStringList colors = colorstr.split(QRegExp("\\s+"));
colors.removeLast();
colors.removeFirst();
colors.removeFirst();
colors.removeFirst();
colors.removeFirst();
QVector<QRgb> colortable;
Lookup_Tables ctable;
colortable=ctable.colorPalete1280();
image.setColorTable(colortable);
int cont=0;
for(int a=0;a<=255;a++)
{
for(int b=0;b<=255;b++)
{
if(qCeil(colors.at(cont).toInt()/3.2)>=1280)
{
image.setPixel(b,a, image.colorTable().at(1279));
}
else
{
image.setPixel(b,a, image.colorTable().at(qCeil(colors.at(cont).toUInt()/3.2)));
}
cont++;
}
}
pixmap = QPixmap::fromImage(image,Qt::ColorOnly);
pixmap=pixmap.scaled(512,512);
scene= new QGraphicsScene(this);
scene->addPixmap(pixmap);
scene->update();
ui->Plot_Window->setScene(scene);
ui->Plot_Window->update();
QCoreApplication::processEvents(QEventLoop::ExcludeUserInputEvents);
}
else if(Count_L.toInt()==2) // 6 bits
{
if(a==(NImage.toInt()-1))
{
myProcess->waitForFinished(NImage.toInt()*((Gap.toInt()*1000)+(Time.toFloat()*1000)+500));
}
else if(a==0)
{
QThread::msleep((Time.toFloat()*1000)+500);
}
else
{
QThread::msleep((Gap.toInt()*1000)+(Time.toFloat()*1000)+500);
}
QByteArray text_response=myProcess->readAll();
QString mystr(text_response);
ui->textBrowser->setText(mystr);
cont++;
//QFileInfoList list = Save_Dir.entryInfoList();
//QFileInfo fileinfo = list.at(0);
//image1 = fileinfo.fileName();
lee.replace(lee.size()-1,1,QString::number(cont));
//qDebug()<<Save_Dir.absolutePath()+"/"+lee+".ppm";
QImage image(256,256,QImage::Format_Indexed8);
image.load(Save_Dir.absolutePath()+"/"+lee+".ppm","pgm");
QVector<QRgb> colortable;
Lookup_Tables ctable;
colortable=ctable.colorPalete64();
image.setColorTable(colortable);
pixmap=pixmap.scaled(512,512);
pixmap = QPixmap::fromImage(image,Qt::ColorOnly);
scene= new QGraphicsScene(this);
scene->addPixmap(pixmap);
scene->update();
ui->Plot_Window->setScene(scene);
ui->Plot_Window->update();
QCoreApplication::processEvents(QEventLoop::ExcludeUserInputEvents);
}
else if(Count_L.toInt()==3) // 24 bits
{
if(a==(NImage.toInt()-1))
{
myProcess->waitForFinished(NImage.toInt()*((Gap.toInt()*1000)+(Time.toFloat()*1000)+1500));
}
else if(a==0)
{
QThread::msleep((Time.toFloat()*1000)+1500);
}
else
{
QThread::msleep((NImage.toInt()*1000)+(Time.toFloat()*1000)+1500);
}
QByteArray text_response=myProcess->readAll();
QString mystr(text_response);
ui->textBrowser->setText(mystr);
cont++;
lee.replace(lee.size()-1,1,QString::number(cont));
QImage image(256,256,QImage::Format_RGB32);
QByteArray teste;
QFile filestr(Save_Dir.absolutePath()+"/"+lee+".ppm");
filestr.open(QIODevice::ReadOnly);
teste=filestr.readAll();
QString colorstr(teste);
QStringList colors = colorstr.split(QRegExp("\\s+"));
colors.removeLast();
colors.removeFirst();
colors.removeFirst();
colors.removeFirst();
colors.removeFirst();
QVector<QRgb> colortable;
Lookup_Tables ctable;
colortable=ctable.colorPalete1280();
image.setColorTable(colortable);
int cont=0;
for(int a=0;a<=255;a++)
{
for(int b=0;b<=255;b++)
{
if(qCeil(colors.at(cont).toInt()/100)>=1536)
{
image.setPixel(b,a, image.colorTable().at(1535));
}
else
{
image.setPixel(b,a, image.colorTable().at(qCeil(colors.at(cont).toUInt()/100)));
}
cont++;
}
}
pixmap = QPixmap::fromImage(image,Qt::ColorOnly);
pixmap=pixmap.scaled(512,512);
scene= new QGraphicsScene(this);
scene->addPixmap(pixmap);
scene->update();
ui->Plot_Window->setScene(scene);
ui->Plot_Window->update();
QCoreApplication::processEvents(QEventLoop::ExcludeUserInputEvents);
}
}
}
}
TemplateCore::GenerationResult FlashCardCore::generateMobileApplication(const QString &input_apk_file, QString &output_file) {
emit generationProgress(5, tr("Preparing workspace..."));
qApp->templateManager()->generator()->cleanWorkspace();
emit generationProgress(10, tr("Extracting raw data from editor..."));
// We need data which will be imported into apk/zip file.
QString quiz_data = editor()->generateBundleData();
if (quiz_data.isEmpty()) {
// No date received, this is big problem.
return BundleProblem;
}
QString temp_folder = qApp->templateManager()->tempDirectory();
QDir temp_directory(temp_folder);
QString base_folder = temp_folder + "/" + APP_LOW_NAME;
QDir base_directory(base_folder);
// Preparation of target bundle file
emit generationProgress(20, tr("Creating base temporary folder..."));
temp_directory.mkdir(APP_LOW_NAME);
base_directory.mkdir("assets");
QFile index_file(base_folder + "/assets/flash_content.xml");
index_file.open(QIODevice::WriteOnly | QIODevice::Text);
emit generationProgress(30, tr("Writting info data into file..."));
QTextStream out(&index_file);
out << quiz_data;
out.flush();
index_file.close();
emit generationProgress(40, tr("Copying template apk file..."));
// Copying of target apk file.
QString new_apk_name = input_apk_file;
if (!QFile::copy(APP_TEMPLATES_PATH + "/" + entryPoint()->baseFolder() + "/" + entryPoint()->mobileApplicationApkFile(),
base_folder + "/" + new_apk_name)) {
qApp->templateManager()->generator()->cleanWorkspace();
return CopyProblem;
}
emit generationProgress(60, tr("Inserting data into apk file..."));
// Inserting bundle file into apk file.
QProcess zip;
zip.setWorkingDirectory(base_folder);
zip.start(qApp->zipUtilityPath(), QStringList() << "-m" << "-r" << new_apk_name << "assets");
zip.waitForFinished();
if (zip.exitCode() != EXIT_STATUS_ZIP_NORMAL) {
// Error during inserting quiz data via zip.
qApp->templateManager()->generator()->cleanWorkspace();
return ZipProblem;
}
emit generationProgress(70, tr("Signing apk file..."));
// Signing and renaming target file.
QString pem_certificate = QDir::toNativeSeparators(APP_CERT_PATH + "/" + CERTIFICATE_PATH);
QString pk_certificate = QDir::toNativeSeparators(APP_CERT_PATH + "/" + KEY_PATH);
QProcess signapk;
signapk.setWorkingDirectory(base_folder);
signapk.start(qApp->javaInterpreterPath(), QStringList() << "-jar" << qApp->signApkUtlityPath() <<
pem_certificate << pk_certificate << new_apk_name <<
QDir::toNativeSeparators(new_apk_name + ".new"));
signapk.waitForFinished();
if (signapk.exitCode() != EXIT_STATUS_SIGNAPK_WORKING) {
qApp->templateManager()->generator()->cleanWorkspace();
return SignApkProblem;
}
emit generationProgress(90, tr("Copying final apk file to output directory..."));
// Now, our file is created. We need to move it to target directory.
if (!IOFactory::copyFile(base_folder + "/" + new_apk_name + ".new",
qApp->templateManager()->outputDirectory() + "/" + new_apk_name)) {
qApp->templateManager()->generator()->cleanWorkspace();
return CopyProblem;
}
output_file = QDir(qApp->templateManager()->outputDirectory()).filePath(new_apk_name);
// Removing temporary files and exit.
qApp->templateManager()->generator()->cleanWorkspace();
return Success;
}
void UdpManager::readUDP()
{
QByteArray Temp;
Temp.resize(socket->pendingDatagramSize());
QHostAddress sender;
quint16 senderPort;
socket->readDatagram(Temp.data(),Temp.size(),&sender,&senderPort);
QString debugMessage = "Got \"" + QString(Temp.data()) + "\" from " + sender.toString() + ":"+ QString::number(senderPort) + " (UDP)";
emit updateClientGUIConsole(debugMessage);
QString compareString = "BLENDER";
QString message;
if(Temp.data() == compareString)
{
if (workerIsBusy)
message = "BLENDER0"; //is busy
else{
if (isGPUWorker)
message = "BLENDER2"; // is available GPU-Worker
else
message = "BLENDER1"; // is available CPU-Worker
}
writeUDP(message, sender);
}
else if( QString(Temp.data()).at(0) == '#' && !workerIsBusy )
{
message = "";
QString filepathToBlend = QDir::currentPath() + "/awesome.blend";
QByteArray fileData;
QFile file( filepathToBlend ); //e.g.: /.../build/awesome.blend
if( file.open(QIODevice::ReadOnly) )
{
fileData = file.readAll();
file.close();
//Generate MD5 Hash
QByteArray hashData = QCryptographicHash::hash(fileData, QCryptographicHash::Md5);
file_hash = hashData.toHex();
qDebug() << "Hex-Hash: " << hashData.toHex();
}
else
{
//Error
file_hash = "Th15I5Th3DummymD5HasH0fGSORF.0RG";
}
//Send UDP Response
writeUDP( "#" + file_hash, sender );
if(file_hash==QString(Temp.data()).remove('#') )
{
emit setFileCached(true);
}
else
{
emit setFileCached(false);
}
}
else if( QString(Temp.data()).startsWith("killall"))
{
qDebug()<<"Bye Bye Blender";
QProcess *myProcess = new QProcess(this);
myProcess->start("killall blender");
myProcess->waitForFinished();
}
emit setServerAddress(sender);
}
bool ALACDecoder::decode(const QString &sourceFile, const QString &outputFile, volatile bool *abortFlag)
{
QProcess process;
QStringList args;
args << "--decode";
args << "-o" << QDir::toNativeSeparators(outputFile);
args << QDir::toNativeSeparators(sourceFile);
if(!startProcess(process, m_binary, args))
{
return false;
}
bool bTimeout = false;
bool bAborted = false;
int prevProgress = -1;
//The ALAC Decoder doesn't actually send any status updates :-[
//emit statusUpdated(20 + (QUuid::createUuid().data1 % 60));
QRegExp regExp("\\[(\\d+)\\.(\\d)%\\]");
while(process.state() != QProcess::NotRunning)
{
if(*abortFlag)
{
process.kill();
bAborted = true;
emit messageLogged("\nABORTED BY USER !!!");
break;
}
process.waitForReadyRead(m_processTimeoutInterval);
if(!process.bytesAvailable() && process.state() == QProcess::Running)
{
process.kill();
qWarning("ALAC process timed out <-- killing!");
emit messageLogged("\nPROCESS TIMEOUT !!!");
bTimeout = true;
break;
}
while(process.bytesAvailable() > 0)
{
QByteArray line = process.readLine();
QString text = QString::fromUtf8(line.constData()).simplified();
if(regExp.lastIndexIn(text) >= 0)
{
bool ok[2] = {false, false};
int intVal[2] = {0, 0};
intVal[0] = regExp.cap(1).toInt(&ok[0]);
intVal[1] = regExp.cap(2).toInt(&ok[1]);
if(ok[0] && ok[1])
{
int progress = qRound(static_cast<double>(intVal[0]) + (static_cast<double>(intVal[1]) / 10.0));
if(progress > prevProgress)
{
emit statusUpdated(progress);
prevProgress = qMin(progress + 2, 99);
}
}
}
else if(!text.isEmpty())
{
emit messageLogged(text);
}
}
}
process.waitForFinished();
if(process.state() != QProcess::NotRunning)
{
process.kill();
process.waitForFinished(-1);
}
emit statusUpdated(100);
emit messageLogged(QString().sprintf("\nExited with code: 0x%04X", process.exitCode()));
if(bTimeout || bAborted || process.exitCode() != EXIT_SUCCESS || QFileInfo(outputFile).size() == 0)
{
return false;
}
return true;
}
// Index any PDFs that are attached. Basically it turns the PDF into text and adds it the same
// way as a note's body
void IndexRunner::indexAttachment(qint32 lid, Resource &r) {
if (!officeFound)
return;
QLOG_DEBUG() << "indexing attachment to note " << lid;
if (!keepRunning || pauseIndexing) {
indexTimer->start();
return;
}
ResourceTable rtable(&db->conn);
qint32 reslid = rtable.getLid(r.guid);
if (lid <= 0) {
indexTimer->start();
return;
}
QLOG_DEBUG() << "Resource " << reslid;
QString extension = "";
ResourceAttributes attributes;
if (r.attributes.isSet())
attributes = r.attributes;
if (attributes.fileName.isSet()) {
extension = attributes.fileName;
int i = extension.indexOf(".");
extension = extension.mid(i);
}
if (extension != ".doc" && extension != ".xls" && extension != ".ppt" &&
extension != ".docx" && extension != ".xlsx" && extension != ".pptx" &&
extension != ".pps" && extension != ".pdf" && extension != ".odt" &&
extension != ".odf" && extension != ".ott" && extension != ".odm" &&
extension != ".html" && extension != ".txt" && extension != ".oth" &&
extension != ".ods" && extension != ".ots" && extension != ".odg" &&
extension != ".otg" && extension != ".odp" && extension != ".otp" &&
extension != ".odb" && extension != ".oxt" && extension != ".htm" &&
extension != ".docm")
return;
QString file = global.fileManager.getDbaDirPath() + QString::number(reslid) +extension;
QFile dataFile(file);
if (!dataFile.exists()) {
QDir dir(global.fileManager.getDbaDirPath());
QStringList filterList;
filterList.append(QString::number(lid)+".*");
QStringList list= dir.entryList(filterList, QDir::Files);
if (list.size() > 0) {
file = global.fileManager.getDbaDirPath()+list[0];
}
}
QString outDir = global.fileManager.getTmpDirPath();
QProcess sofficeProcess;
QString cmd = "soffice --headless --convert-to txt:\"Text\" --outdir "
+outDir + " "
+file;
sofficeProcess.start(cmd,
QIODevice::ReadWrite|QIODevice::Unbuffered);
QLOG_DEBUG() << "Starting soffice ";
sofficeProcess.waitForStarted();
QLOG_DEBUG() << "Waiting for completion";
sofficeProcess.waitForFinished();
int rc = sofficeProcess.exitCode();
QLOG_DEBUG() << "soffice Errors:" << sofficeProcess.readAllStandardError();
QLOG_DEBUG() << "soffice Output:" << sofficeProcess.readAllStandardOutput();
QLOG_DEBUG() << "return code:" << rc;
if (rc == 255) {
QLOG_ERROR() << "soffice not found. Disabling attachment indexing.";
this->officeFound = false;
return;
}
QFile txtFile(outDir+QString::number(reslid) +".txt");
if (txtFile.open(QIODevice::ReadOnly)) {
QString text;
text = txtFile.readAll();
NSqlQuery sql(db->conn);
sql.prepare("Insert into SearchIndex (lid, weight, source, content) values (:lid, :weight, 'recognition', :content)");
sql.bindValue(":lid", lid);
sql.bindValue(":weight", 100);
sql.bindValue(":content", text);
QLOG_DEBUG() << "Adding note resource to index DB";
sql.exec();
txtFile.close();
}
QDir dir;
dir.remove(outDir+QString::number(reslid) +".txt");
}
void MainWindow::downloadFinished(QNetworkReply *reply)
{
QScrollBar *sb = ui->textBrowser->verticalScrollBar();
QUrl url = reply->url();
if (reply->error()) {
if ( !url.toString().contains("hgt.zip") ) {
ui->textBrowser->append("Download of " + QString(url.toEncoded().constData()) + " failed: " + QString(reply->errorString()));
sb->setValue(sb->maximum()); // get the info shown
}
QString fileUrl = url.toEncoded().constData();
} else {
QString path = url.path();
QString fileName = QFileInfo(path).fileName();
if (fileName.isEmpty()) fileName = "download";
QDir dir(dataDirectory);
dir.mkpath(dataDirectory);
QFile file(dataDirectory+"/"+fileName);
if (fileName.contains("dl")) {
// obtain url
QFile file(dataDirectory+"/"+fileName);
} else if (fileName.contains("hgt")) {
// obtain elevation files
dir.mkpath(dataDirectory+"/SRTM-3/");
file.setFileName(dataDirectory+"/SRTM-3/"+fileName);
GUILog( url.toString() + "\n", "download" );
}
if (file.open(QIODevice::WriteOnly)) {
file.write(reply->readAll());
file.close();
}
// download actual shapefile package
if (fileName.contains("dl")) {
QFile dlFile(dataDirectory+"/"+fileName);
if (!dlFile.open(QIODevice::ReadOnly | QIODevice::Text))
return;
QTextStream textStream( &dlFile);
QString dlUrl = textStream.readAll();
dlUrl.remove("<p>The document has moved <a href=\"");
dlUrl.remove("\">here</a></p>\n");
QNetworkReply *r = _manager->get(QNetworkRequest("http://mapserver.flightgear.org"+dlUrl));
connect(r, SIGNAL(downloadProgress(qint64, qint64)), this, SLOT(downloadShapefilesProgressBar(qint64, qint64)));
}
ui->textBrowser->append("Download of "+QString(url.toEncoded().constData())+" succeded saved to: "+QString(fileName));
sb->setValue(sb->maximum()); // get the info shown
// unzip shapefile package
if (fileName.contains("-")) {
// unpack zip
QString arguments;
#ifdef Q_OS_WIN
arguments += "7z.exe x \""+dataDirectory+"/"+fileName+"\" -o\""+dataDirectory+"\" -aoa";
#endif
#ifdef Q_OS_UNIX
arguments += "unzip -o "+dataDirectory+"/"+fileName+" -d "+dataDirectory;
#endif
//ui->textBrowser->append(arguments);
GUILog( arguments + "\n", "download" );
QProcess proc;
proc.start(arguments, QIODevice::ReadWrite);
proc.waitForReadyRead();
proc.waitForFinished(-1);
// delete temporary files
QFile shapeFile(dataDirectory+"/"+fileName);
shapeFile.remove();
QFile dlshpFile(dataDirectory+"/dlshp");
dlshpFile.remove();
// re-enable download button
ui->downloadShapefilesButton->setText("Download shapefiles");
ui->downloadShapefilesButton->setEnabled(1);
}
if (fileName.contains(".hgt.zip")){
// adjust progress bar
ui->downloadElevationProgressBar->setValue(ui->downloadElevationProgressBar->value()+1);
}
}
// re-enable download button
if (ui->downloadElevationProgressBar->value() == ui->downloadElevationProgressBar->maximum()) {
ui->downloadElevationButton->setEnabled(1);
}
}
void MetaEditorSupportPlugin::generateEditorWithQrmc()
{
qrmc::MetaCompiler metaCompiler(*mLogicalRepoApi, ".");
IdList const metamodels = mLogicalRepoApi->children(Id::rootId());
QProgressBar *progress = new QProgressBar(mMainWindowInterface->windowWidget());
progress->show();
int const progressBarWidth = 240;
int const progressBarHeight = 20;
QApplication::processEvents();
QRect const screenRect = qApp->desktop()->availableGeometry();
progress->move(screenRect.width() / 2 - progressBarWidth / 2, screenRect.height() / 2 - progressBarHeight / 2);
progress->setFixedWidth(progressBarWidth);
progress->setFixedHeight(progressBarHeight);
progress->setRange(0, 100);
int forEditor = 60 / metamodels.size();
for (Id const &key : metamodels) {
QString const objectType = key.element();
if (objectType == "MetamodelDiagram" && mLogicalRepoApi->isLogicalElement(key)) {
QString nameOfTheDirectory = mLogicalRepoApi->stringProperty(key, "name of the directory");
QString nameOfMetamodel = mLogicalRepoApi->stringProperty(key, "name");
QString nameOfPlugin = nameOfTheDirectory.split("/").last();
if (QMessageBox::question(mMainWindowInterface->windowWidget()
, tr("loading..")
, QString(tr("Do you want to compile and load editor %1?")).arg(nameOfPlugin)
, QMessageBox::Yes, QMessageBox::No)
== QMessageBox::No)
{
continue;
}
progress->setValue(5);
const QString normalizedName = nameOfMetamodel.at(0).toUpper() + nameOfMetamodel.mid(1);
const bool stateOfLoad = mMainWindowInterface->pluginLoaded(normalizedName);
if (!mMainWindowInterface->unloadPlugin(normalizedName)) {
progress->close();
delete progress;
return;
}
if (!metaCompiler.compile(nameOfMetamodel)) { // generating source code for all metamodels
QMessageBox::warning(mMainWindowInterface->windowWidget()
, tr("error")
, tr("Cannot generate source code for editor ") + nameOfPlugin);
continue;
}
progress->setValue(20);
QStringList qmakeArgs;
qmakeArgs.append("CONFIG+=" + mLogicalRepoApi->stringProperty(key, "buildConfiguration"));
qmakeArgs.append(nameOfMetamodel + ".pro");
QProcess builder;
builder.setWorkingDirectory(nameOfTheDirectory);
const QStringList environment = QProcess::systemEnvironment();
builder.setEnvironment(environment);
builder.start(SettingsManager::value("pathToQmake").toString(), qmakeArgs);
qDebug() << "qmake";
if ((builder.waitForFinished()) && (builder.exitCode() == 0)) {
progress->setValue(40);
builder.start(SettingsManager::value("pathToMake").toString());
bool finished = builder.waitForFinished(100000);
qDebug() << "make";
if (finished && (builder.exitCode() == 0)) {
if (stateOfLoad) {
QMessageBox::warning(mMainWindowInterface->windowWidget()
, tr("Attention!"), tr("Please restart QReal."));
progress->close();
delete progress;
return;
}
qDebug() << "make ok";
progress->setValue(progress->value() + forEditor / 2);
if (!nameOfMetamodel.isEmpty()) {
if (!mMainWindowInterface->unloadPlugin(normalizedName)) {
QMessageBox::warning(mMainWindowInterface->windowWidget()
, tr("error")
, tr("cannot unload plugin ") + normalizedName);
progress->close();
delete progress;
continue;
}
}
QString suffix = "";
if (mLogicalRepoApi->stringProperty(key, "buildConfiguration") == "debug") {
suffix = "-d";
}
QString const generatedPluginFileName = SettingsManager::value("prefix").toString()
+ nameOfMetamodel
+ suffix
+ "."
+ SettingsManager::value("pluginExtension").toString()
;
if (mMainWindowInterface->loadPlugin(generatedPluginFileName, normalizedName)) {
progress->setValue(progress->value() + forEditor / 2);
}
}
progress->setValue(100);
}
}
}
if (progress->value() != 100) {
QMessageBox::warning(mMainWindowInterface->windowWidget(), tr("error"), tr("cannot load new editor"));
}
progress->setValue(100);
progress->close();
delete progress;
}
void Wizard::checkMltComponents()
{
m_mltCheck.programList->setColumnCount(2);
m_mltCheck.programList->setRootIsDecorated(false);
m_mltCheck.programList->setHeaderHidden(true);
QSize itemSize(20, fontMetrics().height() * 2.5);
m_mltCheck.programList->setColumnWidth(0, 30);
m_mltCheck.programList->setIconSize(QSize(24, 24));
QTreeWidgetItem *mltitem = new QTreeWidgetItem(m_mltCheck.programList);
QTreeWidgetItem *meltitem = new QTreeWidgetItem(m_mltCheck.programList, QStringList() << QString() << i18n("Melt") + " (" + KdenliveSettings::rendererpath() + ')');
meltitem->setData(1, Qt::UserRole, i18n("Required for rendering (part of MLT package)"));
meltitem->setSizeHint(0, itemSize);
meltitem->setIcon(0, m_okIcon);
// Check MLT's installed producers
QProcess checkProcess;
checkProcess.start(KdenliveSettings::rendererpath(), QStringList() << "-query" << "producer");
if (!checkProcess.waitForStarted()) {
meltitem->setIcon(0, m_badIcon);
meltitem->setData(1, Qt::UserRole, i18n("Error starting MLT's command line player (melt)"));
button(QWizard::NextButton)->setEnabled(false);
} else {
checkProcess.waitForFinished();
QByteArray result = checkProcess.readAllStandardError();
// Check MLT avformat module
QTreeWidgetItem *avformatItem = new QTreeWidgetItem(m_mltCheck.programList, QStringList() << QString() << i18n("Avformat module (FFmpeg)"));
avformatItem->setData(1, Qt::UserRole, i18n("Required to work with various video formats (hdv, mpeg, flash, ...)"));
avformatItem->setSizeHint(0, itemSize);
if (!result.contains("- avformat")) {
avformatItem->setIcon(0, m_badIcon);
m_mltCheck.tabWidget->setTabEnabled(1, false);
} else {
avformatItem->setIcon(0, m_okIcon);
// Make sure we have MLT > 0.3.4
bool recentMlt = false;
int version = 0;
QString mltVersion;
QString exepath = KStandardDirs::findExe("pkg-config");
if (!exepath.isEmpty()) {
checkProcess.start(exepath, QStringList() << "--variable=version" << "mlt++");
if (!checkProcess.waitForStarted()) {
kDebug() << "// Error querying MLT's version";
} else {
checkProcess.waitForFinished();
mltVersion = checkProcess.readAllStandardOutput();
version = 100 * mltVersion.section('.', 0, 0).toInt() + 10 * mltVersion.section('.', 1, 1).toInt() + mltVersion.section('.', 2, 2).toInt();
kDebug() << "// FOUND MLT's pkgconfig version: " << version;
if (version > 34) recentMlt = true;
}
}
if (version == 0) {
checkProcess.start(KdenliveSettings::rendererpath(), QStringList() << "--version");
if (!checkProcess.waitForStarted()) {
kDebug() << "// Error querying MLT's version";
} else {
checkProcess.waitForFinished();
mltVersion = checkProcess.readAllStandardError();
mltVersion = mltVersion.section('\n', 0, 0).simplified();
mltVersion = mltVersion.section(' ', -1).simplified();
version = 100 * mltVersion.section('.', 0, 0).toInt() + 10 * mltVersion.section('.', 1, 1).toInt() + mltVersion.section('.', 2, 2).toInt();
kDebug() << "// FOUND MLT version: " << version;
if (version >= 40) recentMlt = true;
}
}
mltitem->setText(1, i18n("MLT version: %1", mltVersion.simplified()));
mltitem->setSizeHint(0, itemSize);
if (version < recommendedMltVersion) {
mltitem->setData(1, Qt::UserRole, i18n("Please upgrade to the latest MLT version"));
mltitem->setIcon(0, m_badIcon);
} else {
mltitem->setData(1, Qt::UserRole, i18n("MLT version is correct"));
mltitem->setIcon(0, m_okIcon);
}
if (recentMlt) {
// Check installed audio codecs
QProcess checkProcess2;
checkProcess2.start(KdenliveSettings::rendererpath(), QStringList() << "noise:" << "-consumer" << "avformat" << "acodec=list");
if (!checkProcess2.waitForStarted()) {
m_mltCheck.tabWidget->setTabEnabled(1, false);
kDebug() << "// Error parsing MLT's avformat codecs";
} else {
checkProcess2.waitForFinished();
QByteArray codecList = checkProcess2.readAllStandardError();
QString acodecList(codecList);
QStringList result;
QStringList alist = acodecList.split('\n', QString::SkipEmptyParts);
for (int i = 0; i < alist.count(); i++) {
if (alist.at(i).contains("- ")) result.append(alist.at(i).section("- ", 1).simplified().toLower());
}
m_mltCheck.acodecs_list->addItems(result);
KdenliveSettings::setAudiocodecs(result);
//kDebug()<<"// FOUND LIST:\n\n"<<m_audioCodecs<<"\n\n++++++++++++++++++++";
}
// Check video codecs
checkProcess2.start(KdenliveSettings::rendererpath(), QStringList() << "noise:" << "-consumer" << "avformat" << "vcodec=list");
if (!checkProcess2.waitForStarted()) {
kDebug() << "// Error parsing MLT's avformat codecs";
} else {
checkProcess2.waitForFinished();
QByteArray codecList = checkProcess2.readAllStandardError();
QString vcodecList(codecList);
QStringList result;
QStringList vlist = vcodecList.split('\n', QString::SkipEmptyParts);
for (int i = 0; i < vlist.count(); i++) {
if (vlist.at(i).contains("- ")) result.append(vlist.at(i).section("- ", 1).simplified().toLower());
}
m_mltCheck.vcodecs_list->addItems(result);
KdenliveSettings::setVideocodecs(result);
//kDebug()<<"// FOUND LIST:\n\n"<<m_videoCodecs<<"\n\n++++++++++++++++++++";
}
// Check formats
checkProcess2.start(KdenliveSettings::rendererpath(), QStringList() << "noise:" << "-consumer" << "avformat" << "f=list");
if (!checkProcess2.waitForStarted()) {
kDebug() << "// Error parsing MLT's avformat codecs";
} else {
checkProcess2.waitForFinished();
QByteArray codecList = checkProcess2.readAllStandardError();
QString vcodecList(codecList);
QStringList result;
QStringList vlist = vcodecList.split('\n', QString::SkipEmptyParts);
for (int i = 0; i < vlist.count(); i++) {
if (vlist.at(i).contains("- ")) {
QString format = vlist.at(i).section("- ", 1).simplified().toLower();
if (format.contains(',')) {
QStringList sub = format.split(',', QString::SkipEmptyParts);
for (int j = 0; j < sub.count(); j++)
result.append(sub.at(j));
} else result.append(format);
}
}
m_mltCheck.formats_list->addItems(result);
KdenliveSettings::setSupportedformats(result);
//kDebug()<<"// FOUND LIST:\n\n"<<m_videoCodecs<<"\n\n++++++++++++++++++++";
}
}
}
// Check MLT dv module
QTreeWidgetItem *dvItem = new QTreeWidgetItem(m_mltCheck.programList, QStringList() << QString() << i18n("DV module (libdv)"));
dvItem->setData(1, Qt::UserRole, i18n("Required to work with dv files if avformat module is not installed"));
dvItem->setSizeHint(0, itemSize);
if (!result.contains("- libdv")) {
dvItem->setIcon(0, m_badIcon);
} else {
dvItem->setIcon(0, m_okIcon);
}
// Check MLT image format module
QTreeWidgetItem *imageItem = new QTreeWidgetItem(m_mltCheck.programList, QStringList() << QString() << i18n("QImage module"));
imageItem->setData(1, Qt::UserRole, i18n("Required to work with images"));
imageItem->setSizeHint(0, itemSize);
if (!result.contains("- qimage")) {
imageItem->setIcon(0, m_badIcon);
imageItem = new QTreeWidgetItem(m_mltCheck.programList, QStringList() << QString() << i18n("Pixbuf module"));
imageItem->setData(1, Qt::UserRole, i18n("Required to work with images"));
imageItem->setSizeHint(0, itemSize);
if (!result.contains("- pixbuf")) imageItem->setIcon(0, m_badIcon);
else imageItem->setIcon(0, m_okIcon);
} else {
imageItem->setIcon(0, m_okIcon);
}
}
}
foreach (const TestConfiguration *testConfiguration, selectedTests) {
QScopedPointer<TestOutputReader> outputReader;
switch (testConfiguration->testType()) {
case TestTypeQt:
outputReader.reset(new QtTestOutputReader(futureInterface, &testProcess,
testConfiguration->buildDirectory()));
break;
case TestTypeGTest:
outputReader.reset(new GTestOutputReader(futureInterface, &testProcess,
testConfiguration->buildDirectory()));
break;
}
if (futureInterface.isCanceled())
break;
if (!testConfiguration->project())
continue;
QProcessEnvironment environment = testConfiguration->environment().toProcessEnvironment();
QString commandFilePath = executableFilePath(testConfiguration->targetFile(), environment);
if (commandFilePath.isEmpty()) {
futureInterface.reportResult(TestResultPtr(new FaultyTestResult(Result::MessageFatal,
QObject::tr("Could not find command \"%1\". (%2)")
.arg(testConfiguration->targetFile())
.arg(testConfiguration->displayName()))));
continue;
}
if (testConfiguration->testType() == TestTypeQt) {
QStringList argumentList(QLatin1String("-xml"));
if (!metricsOption.isEmpty())
argumentList << metricsOption;
if (testConfiguration->testCases().count())
argumentList << testConfiguration->testCases();
testProcess.setArguments(argumentList);
} else { // TestTypeGTest
QStringList argumentList;
const QStringList &testSets = testConfiguration->testCases();
if (testSets.size()) {
argumentList << QLatin1String("--gtest_filter=")
+ testSets.join(QLatin1Char(':'));
}
if (settings.gtestRunDisabled)
argumentList << QLatin1String("--gtest_also_run_disabled_tests");
if (settings.gtestRepeat)
argumentList << QString::fromLatin1("--gtest_repeat=%1").arg(settings.gtestIterations);
if (settings.gtestShuffle) {
argumentList << QLatin1String("--gtest_shuffle");
argumentList << QString::fromLatin1("--gtest_random_seed=%1").arg(settings.gtestSeed);
}
testProcess.setArguments(argumentList);
}
testProcess.setWorkingDirectory(testConfiguration->workingDirectory());
if (Utils::HostOsInfo::isWindowsHost())
environment.insert(QLatin1String("QT_LOGGING_TO_CONSOLE"), QLatin1String("1"));
testProcess.setProcessEnvironment(environment);
testProcess.setProgram(commandFilePath);
testProcess.start();
bool ok = testProcess.waitForStarted();
QTime executionTimer;
executionTimer.start();
bool canceledByTimeout = false;
if (ok) {
while (testProcess.state() == QProcess::Running) {
if (executionTimer.elapsed() >= timeout) {
canceledByTimeout = true;
break;
}
if (futureInterface.isCanceled()) {
testProcess.kill();
testProcess.waitForFinished();
return;
}
eventLoop.processEvents();
}
}
if (canceledByTimeout) {
if (testProcess.state() != QProcess::NotRunning) {
testProcess.kill();
testProcess.waitForFinished();
}
futureInterface.reportResult(TestResultPtr(
new FaultyTestResult(Result::MessageFatal, QObject::tr(
"Test case canceled due to timeout. \nMaybe raise the timeout?"))));
}
}
void TestAusmt::initTestCase()
{
// Dirs
QDir srcDir (QStandardPaths::writableLocation(QStandardPaths::TempLocation));
if (!srcDir.exists(AUSMTSRC_SUBDIR)) {
QVERIFY(srcDir.mkdir(AUSMTSRC_SUBDIR));
}
QVERIFY(srcDir.cd(AUSMTSRC_SUBDIR));
GET_DIR;
GET_VAR_DIR;
GET_FILES_DIR;
GET_PATCHES_DIR;
// Dump AUSMT into src dir
QDir ausmtResDir (":/ausmtsrc/");
foreach (const QString &fileName, ausmtResDir.entryList(QDir::Files)) {
QFile file (ausmtResDir.absoluteFilePath(fileName));
if (srcDir.exists(fileName)) {
QVERIFY(QFileInfo(srcDir.absoluteFilePath(fileName)).isFile());
QVERIFY(srcDir.remove(fileName));
}
QVERIFY(file.copy(srcDir.absoluteFilePath(fileName)));
}
QDir ausmtTestResDir (":/ausmtsrc-test/");
foreach (const QString &fileName, ausmtTestResDir.entryList(QDir::Files)) {
QFile file (ausmtTestResDir.absoluteFilePath(fileName));
if (srcDir.exists(fileName)) {
QVERIFY(QFileInfo(srcDir.absoluteFilePath(fileName)).isFile());
QVERIFY(srcDir.remove(fileName));
}
QVERIFY(file.copy(srcDir.absoluteFilePath(fileName)));
}
// Make a better constants_root.sh
QFile constantsRoot (srcDir.absoluteFilePath(CONSTANTS_ROOT_SH));
QVERIFY(constantsRoot.open(QIODevice::WriteOnly));
QTextStream constantsRootStream (&constantsRoot);
constantsRootStream << QString("AUSMT_VAR_DIR=%1\n").arg(varDir.absolutePath());
constantsRootStream << QString("PATCH_ROOT_DIR=%1\n").arg(patchesDir.absolutePath());
constantsRootStream << QString("FILES_DIR=%1\n").arg(filesDir.absolutePath());
constantsRootStream << QString("NOTIFY_WRAPPER_EXEC=echo\n");
constantsRoot.close();
// Build AUSMT
QString buildName = srcDir.absoluteFilePath(BUILD_SH);
QFile build (buildName);
QVERIFY(build.exists());
QVERIFY(build.setPermissions(QFileDevice::ReadUser | QFileDevice::WriteUser | QFileDevice::ExeUser));
QProcess buildProcess;
buildProcess.setWorkingDirectory(srcDir.absolutePath());
buildProcess.start(PYTHON, QStringList() << buildName);
buildProcess.waitForFinished(-1);
QCOMPARE(buildProcess.exitCode(), 0);
foreach (const QString &fileName, dir.entryList(QDir::Files)) {
QFile file (dir.absoluteFilePath(fileName));
QVERIFY(file.setPermissions(QFileDevice::ReadUser | QFileDevice::WriteUser | QFileDevice::ExeUser));
}
// Remove src
QVERIFY(srcDir.removeRecursively());
// Prepare patches
preparePatches();
}
void updateINI(const String& infile, const String& outfile)
{
Int this_instance = getIntOption_("instance");
INIUpdater updater;
String tmp_ini_file = File::getTempDirectory() + "/" + File::getUniqueName() + "_INIUpdater.ini";
tmp_files_.push_back(tmp_ini_file);
String path = File::getExecutablePath();
Param p;
ParamXMLFile paramFile;
paramFile.load(infile, p);
// get sections (usually there is only one - or the user has merged INI files manually)
StringList sections = updater.getToolNamesFromINI(p);
if (sections.empty())
{
writeLog_("Update for file " + infile + " failed because tool section does not exist. Check INI file for corruption!");
failed_.push_back(infile);
return;
}
// get version of first section
String version_old = "Unknown";
if (!p.exists(sections[0] + ":version"))
{
writeLog_("No OpenMS version information found in file " + infile + "! Cannot update!");
failed_.push_back(infile);
return;
}
else
{
version_old = p.getValue(sections[0] + ":version");
// TODO: return on newer version?!
}
// update sections
writeDebug_("Section names: " + ListUtils::concatenate(sections, ", "), 1);
bool update_success = true;
for (Size s = 0; s < sections.size(); ++s)
{
String sec_inst = sections[s] + ":" + String(this_instance) + ":";
// check for default instance
if (!p.exists(sec_inst + "debug"))
{
writeLog_("Update for file '" + infile + "' failed because the instance section '" + sec_inst + "' does not exist. Use -instance or check INI file for corruption!");
update_success = false;
break;
}
String new_tool;
String ttype;
// find mapping to new tool (might be the same name)
if (p.exists(sec_inst + "type")) ttype = p.getValue(sec_inst + "type");
if (!updater.getNewToolName(sections[s], ttype, new_tool))
{
String type_text = ((ttype == "") ? "" : " with type '" + ttype + "' ");
writeLog_("Update for file '" + infile + "' failed because the tool '" + sections[s] + "'" + type_text + "is unknown. TOPPAS file seems to be corrupted!");
update_success = false;
break;
}
// get defaults of new tool by calling it
QProcess pr;
QStringList arguments;
arguments << "-write_ini";
arguments << tmp_ini_file.toQString();
arguments << "-instance";
arguments << String(this_instance).toQString();
pr.start((path + "/" + new_tool).toQString(), arguments);
if (!pr.waitForFinished(-1))
{
writeLog_("Update for file '" + infile + "' failed because the tool '" + new_tool + "' returned with an error! Check if the tool works properly.");
update_success = false;
break;
}
// update defaults with old values
Param new_param;
paramFile.load(tmp_ini_file, new_param);
new_param = new_param.copy(new_tool, true);
Param old_param = p.copy(sections[s], true);
new_param.update(old_param);
// push back changes
p.remove(sections[s] + ":");
p.insert(new_tool, new_param);
}
if (!update_success)
{
failed_.push_back(infile);
return;
}
// STORE
if (outfile.empty()) // create a backup
{
QFileInfo fi(infile.toQString());
String backup_filename = String(fi.path()) + "/" + fi.completeBaseName() + "_v" + version_old + ".ini";
QFile::rename(infile.toQString(), backup_filename.toQString());
std::cout << "Backup of input file created: " << backup_filename << std::endl;
// write updated/new file
paramFile.store(infile, p);
}
else
{
paramFile.store(outfile, p);
}
}
const AudioFileModel& AnalyzeTask::analyzeMediaFile(const QString &filePath, AudioFileModel &audioFile)
{
//bool skipNext = false;
QPair<quint32, quint32> id_val(UINT_MAX, UINT_MAX);
quint32 coverType = UINT_MAX;
QByteArray coverData;
QStringList params;
params << L1S("--Language=raw") << L1S("--Output=XML") << L1S("--Full") << L1S("--Cover_Data=base64");
params << QDir::toNativeSeparators(filePath);
QProcess process;
MUtils::init_process(process, QFileInfo(m_mediaInfoBin).absolutePath());
process.start(m_mediaInfoBin, params);
QByteArray data;
data.reserve(16384);
if(!process.waitForStarted())
{
qWarning("MediaInfo process failed to create!");
qWarning("Error message: \"%s\"\n", process.errorString().toLatin1().constData());
process.kill();
process.waitForFinished(-1);
return audioFile;
}
while(process.state() != QProcess::NotRunning)
{
if(MUTILS_BOOLIFY(m_abortFlag))
{
process.kill();
qWarning("Process was aborted on user request!");
break;
}
if(!process.waitForReadyRead())
{
if(process.state() == QProcess::Running)
{
qWarning("MediaInfo time out. Killing the process now!");
process.kill();
process.waitForFinished(-1);
break;
}
}
forever
{
const QByteArray dataNext = process.readAll();
if (dataNext.isEmpty()) {
break; /*no more input data*/
}
data += dataNext.trimmed();
}
}
process.waitForFinished();
if (process.state() != QProcess::NotRunning)
{
process.kill();
process.waitForFinished(-1);
}
while (!process.atEnd())
{
const QByteArray dataNext = process.readAll();
if (dataNext.isEmpty()) {
break; /*no more input data*/
}
data += dataNext.trimmed();
}
#if MUTILS_DEBUG
qDebug("-----BEGIN MEDIAINFO-----\n%s\n-----END MEDIAINFO-----", data.constData());
#endif //MUTILS_DEBUG
return parseMediaInfo(data, audioFile);
}
bool SSHConnectionCLI::executeSSH(const QString& command,
const QStringList& args, QString* stdout_str,
QString* stderr_str, int* ec)
{
QProcess proc;
QStringList fullArgs;
// Add username
if (!m_user.isEmpty())
fullArgs << "-l" << m_user;
// Add port number
fullArgs << "-p" << QString::number(m_port);
// Add hostname
fullArgs << m_host;
// Add command and original arguments
fullArgs << command;
fullArgs << args;
proc.start("ssh", fullArgs);
int timeout_ms = 60000; // one minute
if (!proc.waitForStarted(timeout_ms)) {
qWarning() << QString("Failed to start ssh command with args \"%1\" "
"after %2 seconds.")
.arg(fullArgs.join(","))
.arg(timeout_ms / 1000);
return false;
}
proc.closeWriteChannel();
if (!proc.waitForFinished(timeout_ms)) {
qWarning() << QString("ssh command with args \"%1\" failed to finish "
"within %2 seconds.")
.arg(fullArgs.join(","))
.arg(timeout_ms / 1000);
return false;
}
if (proc.exitCode() == 255) {
qWarning() << QString("ssh command with args \"%1\" returned an exit "
"code of 255. This usually means that ssh failed "
"to connect, but it may also be a valid exit code"
" for the command which was run. Assuming that "
"ssh has errored. Contact the development team "
"if you believe this is an error.")
.arg(fullArgs.join(","))
<< "\nstdout:\n"
<< QString(proc.readAllStandardOutput()) << "\nstderr:\n"
<< QString(proc.readAllStandardError());
return false;
}
if (stdout_str != nullptr)
*stdout_str = QString(proc.readAllStandardOutput());
if (stderr_str != nullptr)
*stderr_str = QString(proc.readAllStandardError());
if (ec != nullptr)
*ec = proc.exitCode();
proc.close();
return true;
}
bool AnalyzeTask::analyzeAvisynthFile(const QString &filePath, AudioFileModel &info)
{
QProcess process;
MUtils::init_process(process, QFileInfo(m_avs2wavBin).absolutePath());
process.start(m_avs2wavBin, QStringList() << QDir::toNativeSeparators(filePath) << "?");
if(!process.waitForStarted())
{
qWarning("AVS2WAV process failed to create!");
qWarning("Error message: \"%s\"\n", process.errorString().toLatin1().constData());
process.kill();
process.waitForFinished(-1);
return false;
}
bool bInfoHeaderFound = false;
while(process.state() != QProcess::NotRunning)
{
if(MUTILS_BOOLIFY(m_abortFlag))
{
process.kill();
qWarning("Process was aborted on user request!");
break;
}
if(!process.waitForReadyRead())
{
if(process.state() == QProcess::Running)
{
qWarning("AVS2WAV time out. Killing process and skipping file!");
process.kill();
process.waitForFinished(-1);
return false;
}
}
while(process.canReadLine())
{
const QString line = QString::fromUtf8(process.readLine().constData()).simplified();
if(!line.isEmpty())
{
if(bInfoHeaderFound)
{
const qint32 index = line.indexOf(':');
if (index > 0)
{
const QString key = line.left(index).trimmed();
const QString val = line.mid(index + 1).trimmed();
if (!(key.isEmpty() || val.isEmpty()))
{
switch (m_avisynthIdx.value(key.toLower(), MI_propertyId_t(-1)))
{
case propertyId_duration: SET_OPTIONAL(quint32, parseUnsigned(val, _tmp), info.techInfo().setDuration(_tmp)); break;
case propertyId_samplingrate: SET_OPTIONAL(quint32, parseUnsigned(val, _tmp), info.techInfo().setAudioSamplerate(_tmp)); break;
case propertyId_channel_s_: SET_OPTIONAL(quint32, parseUnsigned(val, _tmp), info.techInfo().setAudioChannels(_tmp)); break;
case propertyId_bitdepth: SET_OPTIONAL(quint32, parseUnsigned(val, _tmp), info.techInfo().setAudioBitdepth(_tmp)); break;
}
}
}
}
else
{
if(line.contains("[Audio Info]", Qt::CaseInsensitive))
{
info.techInfo().setAudioType("Avisynth");
info.techInfo().setContainerType("Avisynth");
bInfoHeaderFound = true;
}
}
}
}
}
process.waitForFinished();
if(process.state() != QProcess::NotRunning)
{
process.kill();
process.waitForFinished(-1);
}
//Check exit code
switch(process.exitCode())
{
case 0:
qDebug("Avisynth script was analyzed successfully.");
return true;
break;
case -5:
qWarning("It appears that Avisynth is not installed on the system!");
return false;
break;
default:
qWarning("Failed to open the Avisynth script, bad AVS file?");
return false;
break;
}
}
void QgsGPSPlugin::importGPSFile( const QString &inputFileName, QgsBabelFormat *importer,
bool importWaypoints, bool importRoutes,
bool importTracks, const QString &outputFileName,
const QString &layerName )
{
// what features does the user want to import?
QString typeArg;
if ( importWaypoints )
typeArg = QStringLiteral( "-w" );
else if ( importRoutes )
typeArg = QStringLiteral( "-r" );
else if ( importTracks )
typeArg = QStringLiteral( "-t" );
// try to start the gpsbabel process
QStringList babelArgs =
importer->importCommand( mBabelPath, typeArg,
inputFileName, outputFileName );
QgsDebugMsg( QString( "Import command: " ) + babelArgs.join( "|" ) );
QProcess babelProcess;
babelProcess.start( babelArgs.join( QStringLiteral( " " ) ) );
if ( !babelProcess.waitForStarted() )
{
QMessageBox::warning( nullptr, tr( "Could not start process" ),
tr( "Could not start GPSBabel!" ) );
return;
}
// wait for gpsbabel to finish (or the user to cancel)
QProgressDialog progressDialog( tr( "Importing data..." ), tr( "Cancel" ), 0, 0 );
progressDialog.setWindowModality( Qt::WindowModal );
for ( int i = 0; babelProcess.state() == QProcess::Running; ++i )
{
progressDialog.setValue( i / 64 );
if ( progressDialog.wasCanceled() )
return;
}
babelProcess.waitForFinished();
// did we get any data?
if ( babelProcess.exitCode() != 0 )
{
QString babelError( babelProcess.readAllStandardError() );
QString errorMsg( tr( "Could not import data from %1!\n\n" )
.arg( inputFileName ) );
errorMsg += babelError;
QMessageBox::warning( nullptr, tr( "Error importing data" ), errorMsg );
return;
}
// add the layer
if ( importTracks )
emit drawVectorLayer( outputFileName + "?type=track",
layerName, QStringLiteral( "gpx" ) );
if ( importRoutes )
emit drawVectorLayer( outputFileName + "?type=route",
layerName, QStringLiteral( "gpx" ) );
if ( importWaypoints )
emit drawVectorLayer( outputFileName + "?type=waypoint",
layerName, QStringLiteral( "gpx" ) );
emit closeGui();
}
// Function which displays a info box and restarts networking
void Utils::restartNetworking()
{
QMessageBox infoBox;
infoBox.setWindowModality(Qt::ApplicationModal);
infoBox.setWindowTitle(QObject::tr("Restarting network..."));
infoBox.setInformativeText(QObject::tr("Network is restarting, please wait..."));
infoBox.setStandardButtons(QMessageBox::NoButton);
infoBox.show();
QProcess cmd;
cmd.start(QString("/etc/rc.d/netif"), QStringList() << "restart" );
while ( cmd.state() != QProcess::NotRunning ) {
cmd.waitForFinished(100);
QCoreApplication::processEvents();
}
// Set the gateway device name
QString route = getConfFileValue("/etc/rc.conf", "defaultrouter=", 1);
if ( ! route.isEmpty() ) {
infoBox.setInformativeText(QObject::tr("Setting default route..."));
cmd.start(QString("route"), QStringList() << "delete" << "default" );
while ( cmd.state() != QProcess::NotRunning ) {
cmd.waitForFinished(100);
QCoreApplication::processEvents();
}
cmd.start(QString("route"), QStringList() << "add" << "default" << route );
while ( cmd.state() != QProcess::NotRunning ) {
cmd.waitForFinished(100);
QCoreApplication::processEvents();
}
}
// Check for any devices to run DHCP on
QStringList ifs = NetworkInterface::getInterfaces();
for ( QStringList::Iterator it = ifs.begin(); it != ifs.end(); ++it )
{
QString dev = *it;
// Devices we can safely skip
if (dev.indexOf("lo") == 0
|| dev.indexOf("fwe") == 0
|| dev.indexOf("ipfw") == 0
|| dev.indexOf("plip") == 0
|| dev.indexOf("pfsync") == 0
|| dev.indexOf("pflog") == 0
|| dev.indexOf("usbus") == 0
|| dev.indexOf("vboxnet") == 0
|| dev.indexOf("tun") == 0)
continue;
// Check if this device has DHCP enabled
if ( Utils::getConfFileValue( "/etc/rc.conf", "ifconfig_" + dev + "=", 1 ).indexOf("DHCP") != -1 )
{
qDebug() << "Running DHCP on " << dev;
infoBox.setInformativeText(QObject::tr("Running DHCP..."));
cmd.start(QString("/etc/rc.d/dhclient"), QStringList() << "start" << dev );
while ( cmd.state() != QProcess::NotRunning ) {
cmd.waitForFinished(100);
QCoreApplication::processEvents();
}
}
}
infoBox.close();
}
/**
* Starting point for the retracing thread.
*
* Overrides QThread::run().
*/
void Retracer::run()
{
QString msg = QLatin1String("Replay finished!");
/*
* Construct command line
*/
QString prog;
QStringList arguments;
switch (m_api) {
case trace::API_GL:
prog = QLatin1String("glretrace");
break;
case trace::API_EGL:
prog = QLatin1String("eglretrace");
break;
case trace::API_DX:
case trace::API_D3D7:
case trace::API_D3D8:
case trace::API_D3D9:
case trace::API_DXGI:
#ifdef Q_OS_WIN
prog = QLatin1String("d3dretrace");
#else
prog = QLatin1String("wine");
arguments << QLatin1String("d3dretrace.exe");
#endif
break;
default:
emit finished(QLatin1String("Unsupported API"));
return;
}
if (m_singlethread) {
arguments << QLatin1String("--singlethread");
}
if (m_captureState) {
arguments << QLatin1String("-D");
arguments << QString::number(m_captureCall);
} else if (m_captureThumbnails) {
arguments << QLatin1String("-s"); // emit snapshots
arguments << QLatin1String("-"); // emit to stdout
} else if (isProfiling()) {
if (m_profileGpu) {
arguments << QLatin1String("--pgpu");
}
if (m_profileCpu) {
arguments << QLatin1String("--pcpu");
}
if (m_profilePixels) {
arguments << QLatin1String("--ppd");
}
} else {
if (m_doubleBuffered) {
arguments << QLatin1String("--db");
} else {
arguments << QLatin1String("--sb");
}
if (m_benchmarking) {
arguments << QLatin1String("-b");
}
}
arguments << m_fileName;
/*
* Support remote execution on a separate target.
*/
if (m_remoteTarget.length() != 0) {
arguments.prepend(prog);
arguments.prepend(m_remoteTarget);
prog = QLatin1String("ssh");
}
/*
* Start the process.
*/
QProcess process;
process.start(prog, arguments, QIODevice::ReadOnly);
if (!process.waitForStarted(-1)) {
emit finished(QLatin1String("Could not start process"));
return;
}
/*
* Process standard output
*/
QList<QImage> thumbnails;
QVariantMap parsedJson;
trace::Profile* profile = NULL;
process.setReadChannel(QProcess::StandardOutput);
if (process.waitForReadyRead(-1)) {
BlockingIODevice io(&process);
if (m_captureState) {
/*
* Parse JSON from the output.
*
* XXX: QJSON's scanner is inneficient as it abuses single
* character QIODevice::peek (not cheap), instead of maintaining a
* lookahead character on its own.
*/
bool ok = false;
QJson::Parser jsonParser;
// Allow Nan/Infinity
jsonParser.allowSpecialNumbers(true);
#if 0
parsedJson = jsonParser.parse(&io, &ok).toMap();
#else
/*
* XXX: QJSON expects blocking IO, and it looks like
* BlockingIODevice does not work reliably in all cases.
*/
process.waitForFinished(-1);
parsedJson = jsonParser.parse(&process, &ok).toMap();
#endif
if (!ok) {
msg = QLatin1String("failed to parse JSON");
}
} else if (m_captureThumbnails) {
/*
* Parse concatenated PNM images from output.
*/
while (!io.atEnd()) {
image::PNMInfo info;
char header[512];
qint64 headerSize = 0;
int headerLines = 3; // assume no optional comment line
for (int headerLine = 0; headerLine < headerLines; ++headerLine) {
qint64 headerRead = io.readLine(&header[headerSize], sizeof(header) - headerSize);
// if header actually contains optional comment line, ...
if (headerLine == 1 && header[headerSize] == '#') {
++headerLines;
}
headerSize += headerRead;
}
const char *headerEnd = image::readPNMHeader(header, headerSize, info);
// if invalid PNM header was encountered, ...
if (headerEnd == NULL ||
info.channelType != image::TYPE_UNORM8) {
qDebug() << "error: invalid snapshot stream encountered";
break;
}
unsigned channels = info.channels;
unsigned width = info.width;
unsigned height = info.height;
// qDebug() << "channels: " << channels << ", width: " << width << ", height: " << height";
QImage snapshot = QImage(width, height, channels == 1 ? QImage::Format_Mono : QImage::Format_RGB888);
int rowBytes = channels * width;
for (int y = 0; y < height; ++y) {
unsigned char *scanLine = snapshot.scanLine(y);
qint64 readBytes = io.read((char *) scanLine, rowBytes);
Q_ASSERT(readBytes == rowBytes);
(void)readBytes;
}
QImage thumb = thumbnail(snapshot);
thumbnails.append(thumb);
}
Q_ASSERT(process.state() != QProcess::Running);
} else if (isProfiling()) {
profile = new trace::Profile();
while (!io.atEnd()) {
char line[256];
qint64 lineLength;
lineLength = io.readLine(line, 256);
if (lineLength == -1)
break;
trace::Profiler::parseLine(line, profile);
}
} else {
QByteArray output;
output = process.readAllStandardOutput();
if (output.length() < 80) {
msg = QString::fromUtf8(output);
}
}
}
/*
* Wait for process termination
*/
process.waitForFinished(-1);
if (process.exitStatus() != QProcess::NormalExit) {
msg = QLatin1String("Process crashed");
} else if (process.exitCode() != 0) {
msg = QLatin1String("Process exited with non zero exit code");
}
/*
* Parse errors.
*/
QList<ApiTraceError> errors;
process.setReadChannel(QProcess::StandardError);
QRegExp regexp("(^\\d+): +(\\b\\w+\\b): ([^\\r\\n]+)[\\r\\n]*$");
while (!process.atEnd()) {
QString line = process.readLine();
if (regexp.indexIn(line) != -1) {
ApiTraceError error;
error.callIndex = regexp.cap(1).toInt();
error.type = regexp.cap(2);
error.message = regexp.cap(3);
errors.append(error);
} else if (!errors.isEmpty()) {
// Probably a multiligne message
ApiTraceError &previous = errors.last();
if (line.endsWith("\n")) {
line.chop(1);
}
previous.message.append('\n');
previous.message.append(line);
}
}
/*
* Emit signals
*/
if (m_captureState) {
ApiTraceState *state = new ApiTraceState(parsedJson);
emit foundState(state);
}
if (m_captureThumbnails && !thumbnails.isEmpty()) {
emit foundThumbnails(thumbnails);
}
if (isProfiling() && profile) {
emit foundProfile(profile);
}
if (!errors.isEmpty()) {
emit retraceErrors(errors);
}
emit finished(msg);
}
/** ***************************************************************************/
bool Applications::Application::readDesktopEntry() {
// TYPES http://standards.freedesktop.org/desktop-entry-spec/latest/ar01s05.html
map<QString,map<QString,QString>> values;
// Read the file
QFile desktopFile(_path);
if (desktopFile.open(QIODevice::ReadOnly| QIODevice::Text)) {
QTextStream stream(&desktopFile);
QString key;
QString value;
QString currentGroup;
for (QString line=stream.readLine(); !line.isNull(); line=stream.readLine()) {
line = line.trimmed();
if (line.startsWith('#') || line.isEmpty())
continue;
// Check for groups
if (line.startsWith("[")){
currentGroup = line.mid(1,line.size()-2);
continue;
}
key = line.section('=', 0,0).trimmed();
value = line.section('=', 1, -1).trimmed();
values[currentGroup][key]=value;
}
desktopFile.close();
} else return false;
if (values["Desktop Entry"]["NoDisplay"] == "true")
return false;
// Try to get the (localized name)
QString locale = QLocale().name();
QString shortLocale = locale.left(2);
if (values["Desktop Entry"].count(QString("Name[%1]").arg(locale)))
_name = values["Desktop Entry"][QString("Name[%1]").arg(locale)];
else if (values["Desktop Entry"].count(QString("Name[%1]").arg(shortLocale)))
_name = values["Desktop Entry"][QString("Name[%1]").arg(shortLocale)];
else if (values["Desktop Entry"].count("Name"))
_name = values["Desktop Entry"]["Name"];
else return false;
// Try to get the command
if (values["Desktop Entry"].count("Exec"))
_exec = values["Desktop Entry"]["Exec"];
else return false;
_exec.replace("%c", _name);
_exec.remove(QRegExp("%.")); // Todo standard conform http://standards.freedesktop.org/desktop-entry-spec/latest/ar01s06.html
_term = values["Desktop Entry"]["Terminal"] == "true";
// Try to get the icon
if (values["Desktop Entry"].count("Icon"))
_icon = getIcon(values["Desktop Entry"]["Icon"]);
else {
qWarning() << "No icon specified in " << _path;
_icon = QIcon::fromTheme("exec");
}
// Try to get any [localized] secondary information comment
if (values["Desktop Entry"].count(QString("Comment[%1]").arg(locale)))
_altName = values["Desktop Entry"][QString("Comment[%1]").arg(locale)];
else if (values["Desktop Entry"].count(QString("Comment[%1]").arg(shortLocale)))
_altName = values["Desktop Entry"][QString("Comment[%1]").arg(shortLocale)];
else if (values["Desktop Entry"].count("Comment"))
_altName = values["Desktop Entry"]["Comment"];
else if (values["Desktop Entry"].count(QString("GenericName[%1]").arg(locale)))
_altName = values["Desktop Entry"][QString("GenericName[%1]").arg(locale)];
else if (values["Desktop Entry"].count(QString("GenericName[%1]").arg(shortLocale)))
_altName = values["Desktop Entry"][QString("GenericName[%1]").arg(shortLocale)];
else if (values["Desktop Entry"].count("GenericName"))
_altName = values["Desktop Entry"]["GenericName"];
else
_altName = _exec;
// No additional actions for terminal apps
if(_term)
return true;
// Root actions
QStringList graphicalSudos({"gksu", "kdesu"});
for (const QString &s : graphicalSudos){
QProcess p;
p.start("which", {s});
p.waitForFinished(-1);
if (p.exitCode() == 0)
_actions.push_back(std::make_shared<DesktopAction>(this,
QString("Run %1 as root").arg(_name),
QString("%1 \"%2\"").arg(s, _exec),
_icon));
}
// Desktop entry actions
if (values["Desktop Entry"].count("Actions")){
QString actionsString = values["Desktop Entry"]["Actions"];
QStringList actionStrings = actionsString.split(';',QString::SkipEmptyParts);
QString name;
QString exec;
QString group;
for (const QString &actionString: actionStrings){
// Get the name
group = QString("Desktop Action %1").arg(actionString);
if (!values[group].count("Name")) continue;
name = values[group]["Name"];
// Get the command
group = QString("Desktop Action %1").arg(actionString);
if (!values[group].count("Exec")) continue;
exec = values[group]["Exec"];
// Try to get an icon
group = QString("Desktop Action %1").arg(actionString);
if (values[group].count("Icon"))
_actions.push_back(std::make_shared<DesktopAction>(this, name, exec, getIcon(values[group]["Icon"])));
else
_actions.push_back(std::make_shared<DesktopAction>(this, name, exec, _icon));
}
}
return true;
}
