Calamares::JobResult CreatePartitionTableJob::exec() { Report report( 0 ); QString message = tr( "The installer failed to create a partition table on %1." ).arg( m_device->name() ); CoreBackend* backend = CoreBackendManager::self()->backend(); QScopedPointer< CoreBackendDevice > backendDevice( backend->openDevice( m_device->deviceNode() ) ); if ( !backendDevice.data() ) { return Calamares::JobResult::error( message, tr( "Could not open device %1." ).arg( m_device->deviceNode() ) ); } QScopedPointer< PartitionTable > table( createTable() ); cDebug() << "Creating new partition table of type" << table->typeName() << ", uncommitted yet:\n" << table; QProcess lsblk; lsblk.setProgram( "lsblk" ); lsblk.setProcessChannelMode( QProcess::MergedChannels ); lsblk.start(); lsblk.waitForFinished(); cDebug() << "lsblk:\n" << lsblk.readAllStandardOutput(); QProcess mount; mount.setProgram( "mount" ); mount.setProcessChannelMode( QProcess::MergedChannels ); mount.start(); mount.waitForFinished(); cDebug() << "mount:\n" << mount.readAllStandardOutput(); bool ok = backendDevice->createPartitionTable( report, *table ); if ( !ok ) { return Calamares::JobResult::error( message, QString( "Text: %1\nCommand: %2\nOutput: %3\nStatus: %4" ) .arg( report.toText() ) .arg( report.command() ) .arg( report.output() ) .arg( report.status() ) ); } return Calamares::JobResult::ok(); }
void recursiveFileOpener(QFileInfo file, int & failures, int & total, int & timeOut, int argc, char *argv[]) { const QString jaspExtension(".jasp"); //std::cout << "recursiveFileOpener in " << file.absoluteFilePath().toStdString() << std::endl; if(file.isDir()) { //std::cout << "it is a directory and " << (file.exists() ? "exists" : "does not exist") << std::endl; QDir dir(file.absoluteFilePath()); //std::cout << "QDir dir: " << dir.path().toStdString() << " has " << files.size() << " subfiles!" << std::endl; for(QFileInfo subFile : dir.entryInfoList(QDir::Filter::NoDotAndDotDot | QDir::Files | QDir::Dirs)) recursiveFileOpener(subFile, failures, total, timeOut, argc, argv); } else if(file.isFile()) { //std::cout << "it is a file" << std::endl; if(file.absoluteFilePath().indexOf(jaspExtension) == file.absoluteFilePath().size() - jaspExtension.size()) { //std::cout << "it has the .jasp extension so we will start JASP" << std::endl; #ifndef SEPARATE_PROCESS std::cout << "Found a JASP file (" << file.absoluteFilePath().toStdString() << ") going to start JASP" << std::endl; #endif int result = 1; try{ #ifdef SEPARATE_PROCESS QProcess subJasp; subJasp.setProgram(argv[0]); subJasp.setArguments({file.absoluteFilePath(), "--unitTest", QString::fromStdString("--timeOut="+std::to_string(timeOut)), "-platform", "minimal" }); subJasp.start(); subJasp.waitForFinished((timeOut * 60000) + 10000); std::cerr << subJasp.readAllStandardError().toStdString() << std::endl; result = subJasp.exitCode(); #else //This seems to crash for some reason result = Application(argc, argv, file.absoluteFilePath(), true, timeOut).exec(); #endif } catch(...) { result = -1; } std::cout << "JASP file " << file.absoluteFilePath().toStdString() << (result == 0 ? " succeeded!" : " failed!") << std::endl; if(result != 0) failures++; total++; } } }
static Result runApp(const QString &execPath, const QStringList &args) { // QString outPipePath = FS::TmpFilePath("pipeOut"); QProcess app; app.setProgram(execPath); app.setArguments(args); app.start(); if (!app.waitForStarted()) { qWarning() << "Cmd Exec Failed:" << app.errorString(); return Result(Result::Failed, app.errorString(), "", app.program()); } if (!app.waitForFinished(-1)) { qWarning() << "waitForFinished Failed:" << app.errorString(); return Result(Result::Failed, app.errorString(), "", app.program()); } auto standardError = app.readAllStandardError(); if (QProcess::NormalExit != app.exitStatus()) { qWarning() << "exitStatus error:" << app.exitStatus() << standardError << app.program(); return Result(Result::Failed, standardError, "", app.program()); } if (0 != app.exitCode()) { qWarning() << "exitCode error:" << app.exitCode() << standardError << app.program(); return Result(Result::Failed, standardError, "", app.program()); } Result rest(Result::Success, standardError, app.readAllStandardOutput()); return rest; }
static inline bool performPatchApplication(const QString &patch, const QString &workingDirectory, bool reverse = false) { QProcess process; process.setProgram(PATCH); process.setWorkingDirectory(workingDirectory); process.setStandardInputFile(patch); QStringList arguments; arguments << P1_FLAG << DRY_RUN_FLAG; if (!reverse) { arguments << T_FLAG << N_FLAG; } else { arguments << F_FLAG << R_FLAG; } process.setArguments(arguments); process.start(); process.waitForFinished(-1); if (process.exitCode() != 0) { return false; } arguments.clear(); arguments << P1_FLAG; if (!reverse) { arguments << T_FLAG << N_FLAG; } else { arguments << F_FLAG << R_FLAG; } process.setArguments(arguments); process.start(); process.waitForFinished(-1); return (process.exitCode() == 0); }
Window() { m_layout.addWidget(&m_button); m_process.setProgram("sleep"); m_process.setArguments({"5"}); connect(&m_button, &QPushButton::clicked, &m_process, [=]{ m_process.start(); }); connect(&m_process, (void(QProcess::*)(int))&QProcess::finished, [=]{ m_box.show(); }); }
void TestZot::testZot() { QDir bin(QCoreApplication::applicationDirPath()); QVERIFY(bin.exists()); QDir examples(bin.path() + "/../../examples"); QVERIFY(examples.exists()); QProcess zot; zot.setProgram(bin.path() + QDir::separator() + "zot"); // reverser QStringList args = QStringList() << "--file" << examples.path() + "/reverser.zot" << "--input" << "111000"; zot.setArguments(args); zot.start(); QVERIFY(zot.waitForFinished()); QCOMPARE(zot.exitStatus(), QProcess::NormalExit); QCOMPARE(zot.exitCode(), 0); QCOMPARE(zot.state(), QProcess::NotRunning); QCOMPARE(zot.readAll(), QByteArray("000111\n")); }
Calamares::JobResult ClearMountsJob::exec() { QStringList goodNews; QString deviceName = m_device->deviceNode().split( '/' ).last(); QProcess process; process.setProgram( "sh" ); process.setArguments( { "-c", QString( "echo $(awk '{print $4}' /proc/partitions | sed -e '/name/d' -e '/^$/d' -e '/[1-9]/!d' | grep %1)" ) .arg( deviceName ) } ); process.start(); process.waitForFinished(); QString partitions = process.readAllStandardOutput(); QStringList partitionsList = partitions.simplified().split( ' ' ); // Build a list of partitions of type 82 (Linux swap / Solaris). // We then need to clear them just in case they contain something resumable from a // previous suspend-to-disk. QStringList swapPartitions; process.start( "sfdisk", { "-d", m_device->deviceNode() } ); process.waitForFinished(); // Sample output: // % sudo sfdisk -d /dev/sda // label: dos // label-id: 0x000ced89 // device: /dev/sda // unit: sectors // /dev/sda1 : start= 63, size= 29329345, type=83, bootable // /dev/sda2 : start= 29331456, size= 2125824, type=82 swapPartitions = QString::fromLocal8Bit( process.readAllStandardOutput() ) .split( '\n' ); swapPartitions = swapPartitions.filter( "type=82" ); for ( QStringList::iterator it = swapPartitions.begin(); it != swapPartitions.end(); ++it ) { *it = (*it).simplified().split( ' ' ).first(); } // First we umount all LVM logical volumes we can find process.start( "lvscan", { "-a" } ); process.waitForFinished(); if ( process.exitCode() == 0 ) //means LVM2 tools are installed { QStringList lvscanLines = QString::fromLocal8Bit( process.readAllStandardOutput() ).split( '\n' ); foreach ( const QString& lvscanLine, lvscanLines ) { QString lvPath = lvscanLine.simplified().split( ' ' ).value( 1 ); //second column lvPath = lvPath.replace( '\'', "" ); QString news = tryUmount( lvPath ); if ( !news.isEmpty() ) goodNews.append( news ); }
void AccountsWorker::setPassword(User *user, const QString &oldpwd, const QString &passwd) { QProcess process; process.setProgram("passwd"); process.setArguments(QStringList() << user->name()); process.start(); process.write(QString("%1\n%2\n%3").arg(oldpwd).arg(passwd).arg(passwd).toLatin1()); process.closeWriteChannel(); process.waitForFinished(); qDebug() << Q_FUNC_INFO << process.readAllStandardError() << process.readAllStandardOutput(); Q_EMIT user->passwordModifyFinished(process.exitCode()); }
bool PackageJobThread::installDependency(const QUrl &destUrl) { auto handler = resolveHandler(destUrl.scheme()); if (handler.isEmpty()) return false; QProcess process; process.setProgram(handler); process.setArguments({ destUrl.toString() }); process.setProcessChannelMode(QProcess::ForwardedChannels); process.start(); process.waitForFinished(); return process.exitCode() == 0; }
/** * Open the location of the path, launch a system file browser to the given directory path. If the path is a file then it will open it's containing directory and select it. * * An other on Windows is to use 'SHOpenFolderAndSelectItems(..)'. */ void Utils::openLocation(const QString& path) { #ifdef Q_OS_WIN32 QProcess explorer; if (!QFileInfo(path).isDir()) explorer.setArguments(QStringList() << "/select,"); explorer.setNativeArguments("\"" + QDir::toNativeSeparators(path) + "\""); explorer.setProgram("explorer"); explorer.start(); explorer.waitForFinished(5000); #else QFileInfo fileInfo(path); const QString dirPath = fileInfo.isDir() ? path : fileInfo.absolutePath(); QDesktopServices::openUrl(QUrl("file:///" + dirPath, QUrl::TolerantMode)); #endif }
bool FindPDFImages(QProcess &pdfimagesProcess, const char* imageNames[]) { int index = 0; bool foundPdfImages = false; pdfimagesProcess.setArguments(QStringList("--version")); while(imageNames[index] != 0) { pdfimagesProcess.setProgram(imageNames[index]); pdfimagesProcess.start(); pdfimagesProcess.waitForFinished(-1); if(pdfimagesProcess.error() == QProcess::UnknownError) { foundPdfImages = true; break; } qDebug() << "pdfimage executable not found" << imageNames[index]; index++; } if(!foundPdfImages) { qWarning("pdfimage executable not found"); } return foundPdfImages; }
unsigned char * resample( const QString & nrrd ) { voxmap_size /= rasterization_scale; tile_size /= rasterization_scale; QProcess proc; proc.setProgram( "unu" ); proc.setArguments( QStringList() << "resample" << "-k" << "cubic:1,0" << "-i" << nrrd << "-s" << "=" << QString::number( voxmap_size.X() ) << QString::number( voxmap_size.Y() ) << QString::number( voxmap_size.Z() ) << "-o" << nrrd + ".resampled" ); proc.start(); if( !proc.waitForStarted( -1 ) || !proc.waitForFinished( -1 ) ) return NULL; qint64 bytes = voxmap_size.X() * voxmap_size.Y() * voxmap_size.Z() * voxel_size; char * voxels = new char[ bytes ]; QFile nf( nrrd + ".resampled" ); if( !voxels || !nf.open( QIODevice::ReadOnly ) || nf.size() <= bytes ) return NULL; nf.seek( nf.size() - bytes ); if( nf.read( voxels, bytes ) != bytes ) return NULL; return reinterpret_cast< unsigned char *>( voxels ); }
QString runHof(const QString& file, const QString& input, bool* ok, bool verbose = false, int msecsToTimeout = 5000, Expectation e = Expectation::Normal) { QDir bin(QCoreApplication::applicationDirPath()); QProcess hof; hof.setProgram(bin.path() + QDir::separator() + "hof"); QStringList args = QStringList() << "--file" << file << "--input" << input; if (verbose) { args.append("--verbose"); hof.setProcessChannelMode(QProcess::ForwardedErrorChannel); } hof.setArguments(args); hof.start(); bool finished = hof.waitForFinished(msecsToTimeout); if (!finished) { hof.kill(); hof.waitForFinished(); } /* special value used to indicate stack depth exceeded */ switch (e) { case Expectation::Normal: { *ok = finished && hof.exitStatus() == QProcess::NormalExit && (hof.exitCode() == EXIT_SUCCESS || hof.exitCode() == 2); break; } case Expectation::NoCrash: { *ok = !finished || (hof.exitStatus() == QProcess::NormalExit && (hof.exitCode() == EXIT_SUCCESS || hof.exitCode() == 2)); break; } case Expectation::Timeout: { *ok = !finished; break; } default: *ok = false; break; } if (!*ok) { qDebug() << "exit status:" << hof.exitStatus() << " code:" << hof.exitCode() << " error:" << hof.error(); } return hof.readAll().trimmed(); }
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?")))); } }
QByteArray executeJob(const Job& job) { QProcess sox; QProcess lame; // (1) SoX ///////////////////////////////////////////////////////////////// sox.setProgram(job.soxExe); // Command Line: sox <input1> ... <inputN> -t wav - #if defined(Q_OS_WIN) QString sox_args; foreach(const QString& input, job.inputFiles) { sox_args += _L1C('"'); sox_args += input; sox_args += _L1C('"'); sox_args += _L1C(' '); } sox_args += _L1("-t wav -"); // NOTE: Trailing <SPACE> Above! sox.setNativeArguments(sox_args); #else QStringList sox_args; sox_args << job.inputFiles << _L1("-t") << _L1("wav") << _L1("-"); sox.setArguments(sox_args); #endif // (2) LAME //////////////////////////////////////////////////////////////// lame.setProgram(job.lameExe); // Command Line: lame <options> -S - <output> #if defined(Q_OS_WIN) QString lame_args; lame_args += job.lameOptions; lame_args += _L1(" -S - "); lame_args += _L1C('"'); lame_args += job.outputFile; lame_args += _L1C('"'); lame.setNativeArguments(lame_args); #else QStringList lame_args; lame_args << job.lameOptions << _L1("-S") << _L1("-") << job.outputFile; lame.setArguments(lame_args); #endif // (3) Execute ///////////////////////////////////////////////////////////// sox.setStandardOutputProcess(&lame); sox.start(); lame.start(); sox.waitForFinished(-1); lame.waitForFinished(-1); QByteArray result; result += sox.readAllStandardError(); result += '\n'; result += lame.readAllStandardError(); if( job.renameInput ) { foreach(const QString& input, job.inputFiles) { QFile::rename(input, input+_L1(".done")); } }
QProcess *MainWidget::createProcess() { QProcess *process = new QProcess(this); process->setProgram(qApp->applicationFilePath()); return process; }
bool QUPDUpdater::isUpdateRequested() { qDebug() << "isUpdateRequested"; if (QSettings().contains(QUPD_UPDATED_VERSION_KEY)) { QFileInfo updatedFile (QSettings().value(QUPD_UPDATED_VERSION_KEY).toString()); QFileInfo applicationFile ( qApp->applicationFilePath() ); #if defined Q_OS_MAC QDir dir = applicationFile.dir(); dir.cdUp(); dir.cdUp(); applicationFile = QFileInfo( dir.absolutePath() ); #elif defined Q_OS_WIN qt_ntfs_permission_lookup++; // Allow permissions verification os NTFS file system #endif if (!updatedFile.exists()) { ; // TODO Error } else if (!applicationFile.isWritable()) { qDebug() << "Unwritable file, update aborted"; } else { #if defined Q_OS_WIN ; #elif defined Q_OS_MAC QProcess process; process.setProgram("hdiutil"); process.setArguments(QStringList() << "verify" << updatedFile.absoluteFilePath()); process.start(); process.waitForFinished(); if (process.exitStatus() == QProcess::NormalExit) { QString mountPoint = applicationFile.absolutePath() + "/" + applicationFile.baseName(); // Mount the downloaded dmg process.setProgram("hdiutil"); process.setArguments(QStringList() << "attach" << "-mountpoint" << mountPoint << updatedFile.absoluteFilePath()); process.start(); process.waitForFinished(180000); qDebug() << process.exitStatus(); qDebug() << process.readAllStandardError(); // Replace the Application QString newFile(mountPoint + "/" + qApp->applicationName() +".app"); QString oldFile(applicationFile.absoluteFilePath()); process.setProgram("rm"); process.setArguments(QStringList() << "-rf" << oldFile); process.start(); process.waitForFinished(); process.exitStatus(); process.setProgram("cp"); process.setArguments(QStringList() << "-r" << newFile << oldFile); process.start(); process.waitForFinished(); // Unmount it process.setProgram("hdiutil"); process.setArguments(QStringList() << "detach" << applicationFile.absolutePath() + "/" + applicationFile.baseName()); process.start(); process.waitForFinished(); process.exitCode(); process.exitStatus(); } #endif } #if defined Q_OS_WIN qt_ntfs_permission_lookup--; #endif QSettings().remove(QUPD_UPDATED_VERSION_KEY); } return false; }
int main(int argc, char *argv[]) { QGuiApplication app(argc, argv); app.setApplicationName("ksvg2icns"); app.setApplicationVersion(KICONTHEMES_VERSION_STRING); QCommandLineParser parser; parser.setApplicationDescription(app.translate("main", "Creates an icns file from an svg image")); parser.addPositionalArgument("iconname", app.translate("main", "The svg icon to convert")); parser.addHelpOption(); parser.process(app); if (parser.positionalArguments().isEmpty()) { parser.showHelp(); return 1; } bool isOk; // create a temporary dir to create an iconset QTemporaryDir tmpDir("ksvg2icns"); tmpDir.setAutoRemove(true); isOk = tmpDir.isValid(); EXIT_ON_ERROR(isOk, "Unable to create temporary directory\n"); isOk = QDir(tmpDir.path()).mkdir("out.iconset"); EXIT_ON_ERROR(isOk, "Unable to create out.iconset directory\n"); const QString outPath = tmpDir.path() + "/out.iconset"; const QStringList &args = app.arguments(); EXIT_ON_ERROR(args.size() == 2, "Usage: %s svg-image\n", qPrintable(args.value(0))); const QString &svgFileName = args.at(1); // open the actual svg file QSvgRenderer svg; isOk = svg.load(svgFileName); EXIT_ON_ERROR(isOk, "Unable to load %s\n", qPrintable(svgFileName)); // The sizes are from: // https://developer.apple.com/library/mac/documentation/GraphicsAnimation/Conceptual/HighResolutionOSX/Optimizing/Optimizing.html struct OutFiles { int size; QString out1; QString out2; }; // create the pngs in various resolutions const OutFiles outFiles[] = { { 1024, outPath + "/[email protected]", QString() }, { 512, outPath + "/icon_512x512.png", outPath + "/[email protected]" }, { 256, outPath + "/icon_256x256.png", outPath + "/[email protected]" }, { 128, outPath + "/icon_128x128.png", QString() }, { 64, outPath + "/[email protected]", QString() }, { 32, outPath + "/icon_32x32.png", outPath + "/[email protected]" }, { 16, outPath + "/icon_16x16.png", QString() } }; for (size_t i = 0; i < sizeof(outFiles) / sizeof(OutFiles); ++i) { isOk = writeImage(svg, outFiles[i].size, outFiles[i].out1, outFiles[i].out2); if (!isOk) { return 1; } } // convert the iconset to icns using the "iconutil" command const QString outIcns = QFileInfo(svgFileName).baseName() + ".icns"; const QStringList utilArgs = QStringList() << "-c" << "icns" << "-o" << outIcns << outPath; QProcess iconUtil; iconUtil.setProgram("iconUtil"); iconUtil.setArguments(utilArgs); iconUtil.start("iconutil", utilArgs, QIODevice::ReadOnly); isOk = iconUtil.waitForFinished(-1); EXIT_ON_ERROR(isOk, "Unable to launch iconutil: %s\n", qPrintable(iconUtil.errorString())); EXIT_ON_ERROR(iconUtil.exitStatus() == QProcess::NormalExit, "iconutil crashed!\n"); EXIT_ON_ERROR(iconUtil.exitCode() == 0, "iconutil returned %d\n", iconUtil.exitCode()); return 0; }
void MainWindowVideos::selected(IVideo * pVideo) { // TODO merge with logic from channel QWidget * lPopup = new QWidget(this, Qt::Popup); QPushButton * lButton; lPopup->setAttribute(Qt::WA_DeleteOnClose); lPopup->setLayout(new QBoxLayout(QBoxLayout::TopToBottom, lPopup)); lButton = new QPushButton(lPopup); lButton->setText("Watch!"); QObject::connect(lButton, &QPushButton::clicked, [pVideo,lPopup] { lPopup->setEnabled(false); QUrl lUrl = pVideo->videoUrl(IVideo::URL_VIDEO_DIRECT); lPopup->close(); if (!lUrl.isValid()) return; QString lProgram; QStringList lArguments; lProgram = "/usr/bin/mpv"; if (QFile::exists(lProgram)) { lArguments << "--untimed"; lArguments << "--quiet"; } else { lProgram = "C:\\Program Files\\VideoLAN\\VLC\\vlc.exe"; if (!QFile::exists(lProgram)) lProgram = "C:\\Program Files\\VLC\\vlc.exe"; if (!QFile::exists(lProgram)) lProgram = "C:\\Program Files (x86)\\VideoLAN\\VLC\\vlc.exe"; if (!QFile::exists(lProgram)) lProgram = "C:\\Program Files (x86)\\VLC\\vlc.exe"; } lArguments << lUrl.toString(QUrl::FullyEncoded); QProcess * lProcess = new QProcess(); QObject::connect(lProcess, (void (QProcess::*) (int))&QProcess::finished, [lProcess] (int pExitCode) { lProcess->deleteLater(); }); lProcess->setProcessChannelMode(QProcess::ForwardedChannels); lProcess->setProgram(lProgram); lProcess->setArguments(lArguments); lProcess->start(); }); lPopup->layout()->addWidget(lButton); lButton = new QPushButton(lPopup); lButton->setText("Open in browser"); QObject::connect(lButton, &QPushButton::clicked, [pVideo,lPopup] { lPopup->setEnabled(false); QUrl lUrl = pVideo->videoUrl(IVideo::URL_VIDEO_WEBSITE); lPopup->close(); if (!lUrl.isValid()) return; QDesktopServices::openUrl(lUrl); }); lPopup->layout()->addWidget(lButton); lButton = new QPushButton(lPopup); lButton->setText("Download ..."); QObject::connect(lButton, &QPushButton::clicked, [pVideo,lPopup] { lPopup->setEnabled(false); IDownloader * lDownloader = pVideo->downloader(); lPopup->close(); if (lDownloader == nullptr) return; DownloadWindow * lWindow = new DownloadWindow(lDownloader); lWindow->setAttribute(Qt::WA_DeleteOnClose); lWindow->show(); }); lPopup->layout()->addWidget(lButton); lPopup->move(QCursor::pos() - QPoint(5, 10)); lPopup->show(); }
OsproberEntryList runOsprober( PartitionCoreModule* core ) { QString osproberOutput; QProcess osprober; osprober.setProgram( "os-prober" ); osprober.setProcessChannelMode( QProcess::SeparateChannels ); osprober.start(); if ( !osprober.waitForStarted() ) { cDebug() << "ERROR: os-prober cannot start."; } else if ( !osprober.waitForFinished( 60000 ) ) { cDebug() << "ERROR: os-prober timed out."; } else { osproberOutput.append( QString::fromLocal8Bit( osprober.readAllStandardOutput() ).trimmed() ); } QString osProberReport( "Osprober lines, clean:\n" ); QStringList osproberCleanLines; OsproberEntryList osproberEntries; const auto lines = osproberOutput.split( '\n' ); for ( const QString& line : lines ) { if ( !line.simplified().isEmpty() ) { QStringList lineColumns = line.split( ':' ); QString prettyName; if ( !lineColumns.value( 1 ).simplified().isEmpty() ) prettyName = lineColumns.value( 1 ).simplified(); else if ( !lineColumns.value( 2 ).simplified().isEmpty() ) prettyName = lineColumns.value( 2 ).simplified(); QString path = lineColumns.value( 0 ).simplified(); if ( !path.startsWith( "/dev/" ) ) //basic sanity check continue; FstabEntryList fstabEntries = lookForFstabEntries( path ); QString homePath = findPartitionPathForMountPoint( fstabEntries, "/home" ); osproberEntries.append( { prettyName, path, QString(), canBeResized( core, path ), lineColumns, fstabEntries, homePath } ); osproberCleanLines.append( line ); } } osProberReport.append( osproberCleanLines.join( '\n' ) ); cDebug() << osProberReport; Calamares::JobQueue::instance()->globalStorage()->insert( "osproberLines", osproberCleanLines ); return osproberEntries; }