void QgsGrassModule::run()
{
QgsDebugMsg( "called." );
if ( mProcess.state() == QProcess::Running )
{
mProcess.kill();
mRunButton->setText( tr( "Run" ) );
}
else
{
//QString command;
QStringList arguments;
//mProcess.clearArguments();
//mProcess.addArgument( mXName );
//command = mXName;
// Check if options are ready
QStringList readyErrors = mOptions->ready();
if ( readyErrors.size() > 0 )
{
QString err;
for ( int i = 0; i < readyErrors.size(); i++ )
{
err.append( readyErrors.at( i ) + "<br>" );
}
QMessageBox::warning( 0, tr( "Warning" ), err );
return;
}
// Check/set region
struct Cell_head tempWindow;
bool resetRegion = false;
QgsCoordinateReferenceSystem crs;
if ( mOptions->requestsRegion() ) // direct always
{
if ( !mOptions->inputRegion( &tempWindow, crs, false ) )
{
QMessageBox::warning( 0, tr( "Warning" ), tr( "Cannot get input region" ) );
return;
}
resetRegion = true;
}
else if ( mOptions->usesRegion() )
{
QStringList outsideRegion = mOptions->checkRegion();
if ( outsideRegion.size() > 0 )
{
QMessageBox questionBox( QMessageBox::Question, tr( "Warning" ),
tr( "Input %1 outside current region!" ).arg( outsideRegion.join( QStringLiteral( "," ) ) ),
QMessageBox::Ok | QMessageBox::Cancel );
QPushButton *resetButton = nullptr;
if ( QgsGrass::versionMajor() > 6 || ( QgsGrass::versionMajor() == 6 && QgsGrass::versionMinor() >= 1 ) )
{
resetButton = questionBox.addButton( tr( "Use Input Region" ), QMessageBox::DestructiveRole );
}
questionBox.exec();
QAbstractButton *clicked = questionBox.clickedButton();
if ( clicked == questionBox.button( QMessageBox::Cancel ) )
return;
if ( clicked == resetButton )
resetRegion = true;
if ( resetRegion )
{
if ( !mOptions->inputRegion( &tempWindow, crs, true ) )
{
QMessageBox::warning( 0, tr( "Warning" ), tr( "Cannot get input region" ) );
return;
}
}
}
}
// In direct mode user is warned by select file dialog
if ( !mDirect )
{
// Check if output exists
QStringList outputExists = mOptions->checkOutput();
if ( outputExists.size() > 0 )
{
QMessageBox::StandardButton ret = QMessageBox::question( 0, QStringLiteral( "Warning" ),
tr( "Output %1 exists! Overwrite?" ).arg( outputExists.join( QStringLiteral( "," ) ) ),
QMessageBox::Ok | QMessageBox::Cancel );
if ( ret == QMessageBox::Cancel )
return;
arguments.append( QStringLiteral( "--o" ) );
}
}
// Remember output maps
mOutputVector = mOptions->output( QgsGrassModuleOption::Vector );
QgsDebugMsg( QString( "mOutputVector.size() = %1" ).arg( mOutputVector.size() ) );
mOutputRaster = mOptions->output( QgsGrassModuleOption::Raster );
QgsDebugMsg( QString( "mOutputRaster.size() = %1" ).arg( mOutputRaster.size() ) );
mSuccess = false;
mViewButton->setEnabled( false );
QStringList list = mOptions->arguments();
list << arguments;
QStringList argumentsHtml;
for ( QStringList::Iterator it = list.begin(); it != list.end(); ++it )
{
QgsDebugMsg( "option: " + ( *it ) );
//command.append ( " " + *it );
arguments.append( *it );
//mProcess.addArgument( *it );
// Quote options with special characters so that user
// can copy-paste-run the command
if ( it->contains( QRegExp( "[ <>\\$|;&]" ) ) )
{
argumentsHtml.append( "\"" + *it + "\"" );
}
else
{
argumentsHtml.append( *it );
}
}
/* WARNING - TODO: there was a bug in GRASS 6.0.0 / 6.1.CVS (< 2005-04-29):
* db_start_driver set GISRC_MODE_MEMORY eviroment variable to 1 if
* G_get_gisrc_mode() == G_GISRC_MODE_MEMORY but the variable wasn't unset
* if G_get_gisrc_mode() == G_GISRC_MODE_FILE. Because QGIS GRASS provider starts drivers in
* G_GISRC_MODE_MEMORY mode, the variable remains set in variable when a module is run
* -> unset GISRC_MODE_MEMORY. Remove later once 6.1.x / 6.0.1 is widespread.
* */
putenv( ( char * ) "GISRC_MODE_MEMORY" ); // unset
mOutputTextBrowser->clear();
QProcessEnvironment environment = processEnvironment( mDirect );
environment.insert( QStringLiteral( "GRASS_HTML_BROWSER" ), QgsGrassUtils::htmlBrowserPath() );
// Warning: it is not useful to write requested region to WIND file and
// reset then to original because it is reset before
// the region is read by a module even if waitForStarted() is used
// -> necessary to pass region as environment variable
// but the feature is available in GRASS 6.1 only since 23.3.2006
if ( resetRegion )
{
QString reg = QgsGrass::regionString( &tempWindow );
QgsDebugMsg( "reg: " + reg );
environment.insert( QStringLiteral( "GRASS_REGION" ), reg );
}
if ( mDirect )
{
QStringList variables;
setDirectLibraryPath( environment );
#ifdef Q_OS_WIN
variables << "PATH";
#elif defined(Q_OS_MAC)
variables << "DYLD_LIBRARY_PATH";
#else
variables << QStringLiteral( "LD_LIBRARY_PATH" );
#endif
environment.insert( QStringLiteral( "QGIS_PREFIX_PATH" ), QgsApplication::prefixPath() );
if ( crs.isValid() ) // it should always be valid
{
environment.insert( QStringLiteral( "QGIS_GRASS_CRS" ), crs.toProj4() );
}
// Suppress debug output
environment.insert( QStringLiteral( "QGIS_DEBUG" ), QStringLiteral( "-1" ) );
// Print some important variables
variables << QStringLiteral( "QGIS_PREFIX_PATH" ) << QStringLiteral( "QGIS_GRASS_CRS" ) << QStringLiteral( "GRASS_REGION" );
Q_FOREACH ( const QString &v, variables )
{
mOutputTextBrowser->append( v + "=" + environment.value( v ) + "<BR>" );
}
}
QString commandHtml = mXName + " " + argumentsHtml.join( QStringLiteral( " " ) );
QgsDebugMsg( "command: " + commandHtml );
commandHtml.replace( QLatin1String( "&" ), QLatin1String( "&" ) );
commandHtml.replace( QLatin1String( "<" ), QLatin1String( "<" ) );
commandHtml.replace( QLatin1String( ">" ), QLatin1String( ">" ) );
mOutputTextBrowser->append( "<B>" + commandHtml + "</B>" );
// I was not able to get scripts working on Windows
// via QProcess and sh.exe (MinGW). g.parser runs wellQProcessEnvironment::systemE
// and it sets parameters correctly as environment variables
// but it fails (without error) to re-run the script with
// execlp(). And I could not figure out why it fails.
// Because of this problem we simulate here what g.parser
// normally does and that way we can avoid it.
QStringList execArguments = QgsGrassModule::execArguments( mXName );
if ( execArguments.size() == 0 )
{
QMessageBox::warning( 0, tr( "Warning" ), tr( "Cannot find module %1" ).arg( mXName ) );
return;
}
#ifdef Q_OS_WIN
// we already know it exists from execArguments()
QString exe = QgsGrass::findModule( mXName );
QFileInfo fi( exe );
if ( !fi.isExecutable() )
{
QStringList usedFlagNames;
// Set environment variables
for ( int i = 0; i < arguments.size(); i++ )
{
QString arg = arguments.at( i );
//QString env;
if ( arg.at( 0 ) == '-' ) //flag
{
//env = "GIS_FLAG_" + QString( arg.at( 1 ).toUpper() ) + "=1";
environment.insert( "GIS_FLAG_" + QString( arg.at( 1 ).toUpper() ), "1" );
usedFlagNames.append( arg.at( 1 ) );
}
else // option
{
QStringList opt = arg.split( "=" );
//env = "GIS_OPT_" + opt.takeFirst().toUpper();
//env += "=" + opt.join( "=" ); // rejoin rest
environment.insert( "GIS_OPT_" + opt.takeFirst().toUpper(), opt.join( "=" ) );
}
//environment.append( env );
}
// Set remaining flags
QStringList allFlagNames = mOptions->flagNames();
for ( int i = 0; i < allFlagNames.size(); i++ )
{
bool used = false;
for ( int j = 0; j < usedFlagNames.size(); j++ )
{
if ( usedFlagNames.at( j ) == allFlagNames.at( i ) )
{
used = true;
break;
}
}
if ( used )
continue;
//QString env = "GIS_FLAG_"
// + QString( allFlagNames.at( i ).toUpper() )
// + "=0";
//QgsDebugMsg( "set: " + env );
//environment.append( env );
environment.insert( "GIS_FLAG_" + QString( allFlagNames.at( i ).toUpper() ), "0" );
}
arguments.clear();
arguments.append( "@ARGS_PARSED@" );
}
#endif
QString cmd = execArguments.takeFirst();
execArguments += arguments;
// Freeze output vector on Windows
mOptions->freezeOutput();
mProcess.setProcessEnvironment( environment );
mProcess.start( cmd, execArguments );
emit moduleStarted();
mProcess.waitForStarted();
if ( mProcess.state() != QProcess::Running )
{
QMessageBox::warning( 0, tr( "Warning" ), tr( "Cannot start module: %1" ).arg( mProcess.errorString() ) );
return;
}
mTabWidget->setCurrentIndex( 1 );
mRunButton->setText( tr( "Stop" ) );
}
int main(int argc, char** argv)
{
QCoreApplication app(argc, argv);
const QStringList args = app.arguments();
QString arg_port;
QString arg_server;
QString arg_xmlFile;
bool arg_crash = false;
bool arg_garbage = false;
uint arg_wait = 0;
const QProcessEnvironment sysEnv = QProcessEnvironment::systemEnvironment();
arg_xmlFile = sysEnv.value("QCIT_INPUT_FILE");
for (int i = 1; i < args.size(); ++i) {
const QString& arg = args.at(i);
if (arg.startsWith(QLatin1String("--xml-socket="))) {
arg_server = arg.mid(13, arg.indexOf(':') - 13);
arg_port = arg.mid(13 + arg_server.length() + 1);
} else if (args.size() > i + 1
&& (args.at(i) == QLatin1String("-i")
|| args.at(i) == QLatin1String("--xml-input"))) {
arg_xmlFile = args.at(i+1);
++i;
} else if (arg == QLatin1String("-c") || arg == QLatin1String("--crash")) {
arg_crash = true;
} else if (arg == QLatin1String("-g") || arg == QLatin1String("--garbage")) {
arg_garbage = true;
} else if (args.size() > i + 1 && (arg == QLatin1String("-w") || arg == QLatin1String("--wait"))) {
bool ok;
arg_wait = args.at(i+1).toUInt(&ok);
if (!ok) {
qerr << "ERROR: invalid wait time given" << args.at(i+1) << endl;
usage(qerr);
return 4;
}
} else if (args.at(i) == QLatin1String("--help") || args.at(i) == QLatin1String("-h")) {
usage(qout);
return 0;
}
}
if (arg_xmlFile.isEmpty()) {
qerr << "ERROR: no XML input file given" << endl;
usage(qerr);
return 1;
}
if (arg_server.isEmpty()) {
qerr << "ERROR: no server given" << endl;
usage(qerr);
return 2;
}
if (arg_port.isEmpty()) {
qerr << "ERROR: no port given" << endl;
usage(qerr);
return 3;
}
QFile xmlFile(arg_xmlFile);
if (!xmlFile.exists() || !xmlFile.open(QIODevice::ReadOnly)) {
qerr << "ERROR: invalid XML file" << endl;
usage(qerr);
return 10;
}
bool ok = false;
quint16 port = arg_port.toUInt(&ok);
if (!ok) {
qerr << "ERROR: invalid port" << endl;
usage(qerr);
return 30;
}
QTcpSocket socket;
socket.connectToHost(arg_server, port, QIODevice::WriteOnly);
if (!socket.isOpen()) {
qerr << "ERROR: could not open socket to server:" << arg_server << ":" << port << endl;
usage(qerr);
return 20;
}
if (!socket.waitForConnected()) {
qerr << "ERROR: could not connect to socket: " << socket.errorString() << endl;
return 21;
}
OutputGenerator generator(&socket, &xmlFile);
QObject::connect(&generator, SIGNAL(finished()), &app, SLOT(quit()));
generator.setCrashRandomly(arg_crash);
generator.setOutputGarbage(arg_garbage);
generator.setWait(arg_wait);
return app.exec();
}
// ------------------------------------------------------------------------
void SimMessage::startSimulator()
{
// Using the Doc pointer here is risky as the user may have closed
// the schematic, but converting the SPICE netlists is (hopefully)
// faster than the user (I have no other idea).
QString SimTime;
QString Program;
QStringList Arguments;
QString SimPath = QDir::convertSeparators (QucsHomeDir.absPath());
#ifdef __MINGW32__
QString QucsDigiLib = "qucsdigilib.bat";
QString QucsDigi = "qucsdigi.bat";
QString QucsVeri = "qucsveri.bat";
#else
QString QucsDigiLib = "qucsdigilib";
QString QucsDigi = "qucsdigi";
QString QucsVeri = "qucsveri";
#endif
SimOpt = NULL;
bool isVerilog = false;
// Simulate text window.
if(DocWidget->inherits("QTextEdit")) {
TextDoc * Doc = (TextDoc*)DocWidget;
// Take VHDL file in memory as it could contain unsaved changes.
Stream << Doc->text();
NetlistFile.close();
ProgText->insert(tr("done.")+"\n"); // of "creating netlist...
// Simulation.
if (Doc->simulation) {
SimTime = Doc->SimTime;
QString libs = Doc->Libraries.lower();
#ifdef __MINGW32__
if(libs.isEmpty()) {
libs = "-Wl";
} else {
libs.replace(" ",",-l");
libs = "-Wl,-l" + libs;
}
#else
if(libs.isEmpty()) {
libs = "-c";
} else {
libs.replace(" ",",-l");
libs = "-c,-l" + libs;
}
#endif
Program = pathName(QucsSettings.BinDir + QucsDigi);
Arguments << "netlist.txt" << DataSet << SimTime << pathName(SimPath)
<< pathName(QucsSettings.BinDir) << libs;
}
// Module.
else {
QString text = Doc->text();
VHDL_File_Info VInfo (text);
QString entity = VInfo.EntityName.lower();
QString lib = Doc->Library.lower();
if (lib.isEmpty()) lib = "work";
QString dir = QDir::convertSeparators (QucsHomeDir.path());
QDir vhdlDir(dir);
if(!vhdlDir.exists("vhdl"))
if(!vhdlDir.mkdir("vhdl")) {
ErrText->insert(tr("ERROR: Cannot create VHDL directory \"%1\"!")
.arg(vhdlDir.path()+"/vhdl"));
return;
}
vhdlDir.setPath(vhdlDir.path()+"/vhdl");
if(!vhdlDir.exists(lib))
if(!vhdlDir.mkdir(lib)) {
ErrText->insert(tr("ERROR: Cannot create VHDL directory \"%1\"!")
.arg(vhdlDir.path()+"/"+lib));
return;
}
vhdlDir.setPath(vhdlDir.path()+"/"+lib);
QFile destFile;
destFile.setName(vhdlDir.filePath(entity+".vhdl"));
if(!destFile.open(QIODevice::WriteOnly)) {
ErrText->insert(tr("ERROR: Cannot create \"%1\"!")
.arg(destFile.name()));
return;
}
destFile.writeBlock(text.ascii(), text.length());
destFile.close();
Program = pathName(QucsSettings.BinDir + QucsDigiLib);
Arguments << "netlist.txt" << pathName(SimPath) << entity << lib;
}
}
// Simulate schematic window.
else {
// output NodeSets, SPICE simulations etc.
for(QStringList::Iterator it = Collect.begin();
it != Collect.end(); ++it) {
// don't put library includes into netlist...
if ((*it).right(4) != ".lst" &&
(*it).right(5) != ".vhdl" &&
(*it).right(4) != ".vhd" &&
(*it).right(2) != ".v") {
Stream << *it << '\n';
}
}
Stream << '\n';
isVerilog = ((Schematic*)DocWidget)->isVerilog;
SimTime = ((Schematic*)DocWidget)->createNetlist(Stream, SimPorts);
if(SimTime.length()>0&&SimTime.at(0) == '\xA7') {
NetlistFile.close();
ErrText->insert(SimTime.mid(1));
FinishSimulation(-1);
return;
}
if (isVerilog) {
Stream << "\n"
<< " initial begin\n"
<< " $dumpfile(\"digi.vcd\");\n"
<< " $dumpvars();\n"
<< " #" << SimTime << " $finish;\n"
<< " end\n\n"
<< "endmodule // TestBench\n";
}
NetlistFile.close();
ProgText->insert(tr("done.")+"\n"); // of "creating netlist...
if(SimPorts < 0) {
if((SimOpt = findOptimization((Schematic*)DocWidget))) {
((Optimize_Sim*)SimOpt)->createASCOnetlist();
Program = QucsSettings.AscoDir + "asco"+ executablePostfix;
Arguments << "-qucs" << QucsHomeDir.filePath("asco_netlist.txt")
<< "-o" << "asco_out";
}
else {
Program = QucsSettings.BinDir + "qucsator" + executablePostfix;
Arguments << "-b" << "-g" << "-i"
<< QucsHomeDir.filePath("netlist.txt")
<< "-o" << DataSet;
}
} else {
if (isVerilog) {
Program = pathName(QucsSettings.BinDir + QucsVeri);
Arguments << "netlist.txt" << DataSet
<< SimTime << pathName(SimPath)
<< pathName(QucsSettings.BinDir) << "-c";
} else {
#ifdef __MINGW32__
Program = pathName(QucsSettings.BinDir + QucsDigi);
Arguments << "netlist.txt" << DataSet << SimTime << pathName(SimPath)
<< pathName(QucsSettings.BinDir) << "-Wl" << "-c";
#else
Program = pathName(QucsSettings.BinDir + QucsDigi);
Arguments << "netlist.txt" << DataSet << SimTime << pathName(SimPath)
<< pathName(QucsSettings.BinDir) << "-Wall" << "-c";
#endif
}
}
}
disconnect(&SimProcess, 0, 0, 0);
connect(&SimProcess, SIGNAL(readyReadStandardError()), SLOT(slotDisplayErr()));
connect(&SimProcess, SIGNAL(readyReadStandardOutput()), SLOT(slotDisplayMsg()));
connect(&SimProcess, SIGNAL(finished(int)), SLOT(slotSimEnded(int)));
#ifdef SPEEDUP_PROGRESSBAR
waitForUpdate = false;
#endif
wasLF = false;
ProgressText = "";
#ifdef __MINGW32__
QString sep(";"); // path separator
#else
QString sep(":");
#endif
// append process PATH
QProcessEnvironment env = QProcessEnvironment::systemEnvironment();
env.insert("PATH", env.value("PATH") + sep + QucsSettings.BinDir );
SimProcess.setProcessEnvironment(env);
QFile file(Program);
if ( !file.exists() ){
ErrText->insert(tr("ERROR: Program not found: %1").arg(Program));
FinishSimulation(-1);
return;
}
else
file.close();
SimProcess.start(Program, Arguments); // launch the program
if(!SimProcess.Running) {
ErrText->insert(tr("ERROR: Cannot start simulator!"));
FinishSimulation(-1);
return;
}
}
bool XProcess::startXSession(){
//Check that the necessary info to start the session is available
if( xuser.isEmpty() || xcmd.isEmpty() || xhome.isEmpty() || xde.isEmpty() ){
emit InvalidLogin(); //Make sure the GUI knows that it was a failure
return FALSE;
}
//Backend::log("Starting up Desktop environment ("+xcmd+") as user ("+xuser+")");
//Check for PAM username/password validity
if( !pam_checkPW() ){ emit InvalidLogin(); pam_shutdown(); return FALSE; }
//Save the current user/desktop as the last login
Backend::saveLoginInfo(Backend::getDisplayNameFromUsername(xuser),xde);
// Get the users uid/gid information
struct passwd *pw;
int uid;
char *ok;
if (!(pw = getpwnam(xuser.toLatin1()))) {
uid = strtol(xuser.toLatin1(), &ok, 10);
if (!(pw = getpwuid(uid))) {
emit InvalidLogin(); //Make sure the GUI knows that it was a failure
return FALSE;
}
}
// Get the environment before we drop priv
QProcessEnvironment environ = QProcessEnvironment::systemEnvironment(); //current environment
QWidget *wid = new QWidget();
if (setgid(pw->pw_gid) < 0) {
qDebug() << "setgid() failed!";
emit InvalidLogin(); //Make sure the GUI knows that it was a failure
return FALSE;
}
// Setup our other groups
if (initgroups(xuser.toLatin1(), pw->pw_gid) < 0) {
qDebug() << "initgroups() failed!";
emit InvalidLogin(); //Make sure the GUI knows that it was a failure
setgid(0);
return FALSE;
}
// Lets drop to user privs
if (setuid(pw->pw_uid) < 0) {
qDebug() << "setuid() failed!";
emit InvalidLogin(); //Make sure the GUI knows that it was a failure
return FALSE;
}
//Startup the PAM session
if( !pam_startSession() ){ pam_shutdown(); return FALSE; }
pam_session_open = TRUE; //flag that pam has an open session
QString cmd;
// Configure the DE startup command
// - Setup to run the user's <home-dir>/.xprofile startup script
if(QFile::exists(xhome+"/.xprofile")){
//cmd.append(". "+xhome+"/.xprofile; "); //make sure to start it in parallel
}
// - Add the DE startup command to the end
//cmd.append("dbus-launch --exit-with-session "+xcmd);
cmd.append(xcmd);
//cmd.append("; kill -l KILL"); //to clean up the session afterwards
// Get the current locale code
QLocale mylocale;
QString langCode = mylocale.name();
//Backend::log("Startup command: "+cmd);
// Setup the process environment
// Setup any specialized environment variables
// USER, HOME, and SHELL are set by the "su" login
environ.insert("LOGNAME",xuser); //Login name
environ.insert("USERNAME",xuser); // Username
environ.insert("PATH",environ.value("PATH")+":"+xhome+"/bin"); // Append the user's home dir to the path
if( langCode.toLower() == "c" ){} // do nothing extra to it
else if(!environ.value("MM_CHARSET").isEmpty() ){ langCode.append( "."+environ.value("MM_CHARSET") ); }
else{ langCode.append(".UTF-8"); }
environ.insert("LANG",langCode); //Set the proper localized language
environ.insert("MAIL","/var/mail/"+xuser); //Set the mail variable
environ.insert("GROUP",xuser); //Set the proper group id
environ.insert("SHLVL","0"); //Set the proper shell level
environ.insert("HOME",xhome); //Set the users home directory
this->setProcessEnvironment(environ);
this->setWorkingDirectory(xhome); //set the current directory to the user's home directory
//Log the DE startup outputs as well
this->setStandardOutputFile(xhome+"/.pcdm-startup.log",QIODevice::Truncate);
this->setStandardErrorFile(xhome+"/.pcdm-startup.err",QIODevice::Truncate);
// Startup the process
QMessageBox::warning(wid, "My Application", "CMD: " + cmd, QMessageBox::Ok, QMessageBox::Ok);
this->start(cmd);
return TRUE;
}
void StelFileMgr::init()
{
// Set the userDir member.
#ifdef Q_OS_WIN
QString winApiPath = getWin32SpecialDirPath(CSIDL_APPDATA);
if (!winApiPath.isEmpty())
{
userDir = winApiPath + "\\Stellarium";
}
#elif defined(Q_OS_MAC)
userDir = QDir::homePath() + "/Library/Application Support/Stellarium";
#else
userDir = QDir::homePath() + "/.stellarium";
#endif
#if QT_VERSION >= 0x050A00
if (qEnvironmentVariableIsSet("STEL_USERDIR"))
{
userDir=qEnvironmentVariable("STEL_USERDIR");
}
#else
QByteArray userDirCand=qgetenv("STEL_USERDIR");
if (userDirCand.length()>0)
{
userDir=QString::fromLocal8Bit(userDirCand);
}
#endif
if (!QFile(userDir).exists())
{
qWarning() << "User config directory does not exist: " << QDir::toNativeSeparators(userDir);
}
try
{
makeSureDirExistsAndIsWritable(userDir);
}
catch (std::runtime_error &e)
{
qFatal("Error: cannot create user config directory: %s", e.what());
}
// OK, now we have the userDir set, add it to the search path
fileLocations.append(userDir);
// Determine install data directory location
QProcessEnvironment env = QProcessEnvironment::systemEnvironment();
QString envRoot = env.value("STELLARIUM_DATA_ROOT", ".");
if (QFileInfo(envRoot + QDir::separator() + QString(CHECK_FILE)).exists())
{
installDir = envRoot;
}
else
{
#if defined(Q_OS_MAC)
QString relativePath = "/../Resources";
if (QCoreApplication::applicationDirPath().contains("src")) {
relativePath = "/../..";
}
QFileInfo MacOSdir(QCoreApplication::applicationDirPath() + relativePath);
// These two lines are used to see if the Qt bug still exists.
// The output from C: should simply be the parent of what is show for B:
// qDebug() << "B: " << MacOSdir.absolutePath();
// qDebug() << "C: " << MacOSdir.dir().absolutePath();
QDir ResourcesDir(MacOSdir.absolutePath());
if (!QCoreApplication::applicationDirPath().contains("src")) {
ResourcesDir.cd(QString("Resources"));
}
QFileInfo installLocation(ResourcesDir.absolutePath());
QFileInfo checkFile(installLocation.filePath() + QDir::separator() + QString(CHECK_FILE));
#elif defined(Q_OS_WIN)
QFileInfo installLocation(QCoreApplication::applicationDirPath());
QFileInfo checkFile(installLocation.filePath() + QDir::separator() + QString(CHECK_FILE));
#else
// Linux, BSD, Solaris etc.
// We use the value from the config.h filesystem
QFileInfo installLocation(QFile::decodeName(INSTALL_DATADIR));
QFileInfo checkFile(QFile::decodeName(INSTALL_DATADIR "/" CHECK_FILE));
#endif
#ifdef DEBUG
if (!checkFile.exists())
{ // for DEBUG use sources location
QString debugDataPath = INSTALL_DATADIR_FOR_DEBUG;
checkFile = QFileInfo(debugDataPath + QDir::separator() + CHECK_FILE);
installLocation = QFileInfo(debugDataPath);
}
#endif
if (checkFile.exists())
{
installDir = installLocation.filePath();
}
else
{
qWarning() << "WARNING StelFileMgr::StelFileMgr: could not find install location:"
<< QDir::toNativeSeparators(installLocation.filePath())
<< " (we checked for "
<< QDir::toNativeSeparators(checkFile.filePath()) << ").";
qWarning() << "Maybe this is AppImage or something similar? Let's check relative path...";
// This hook has been added after reverse-engineering an AppImage application
QString relativePath = QCoreApplication::applicationDirPath() + QString("/../share/stellarium");
checkFile = QFileInfo(relativePath + QDir::separator() + CHECK_FILE);
if (checkFile.exists())
{
installDir = relativePath;
}
else
{
qWarning() << "WARNING StelFileMgr::StelFileMgr: could not find install location:"
<< QDir::toNativeSeparators(relativePath)
<< " (we checked for "
<< QDir::toNativeSeparators(checkFile.filePath()) << ").";
qWarning() << "Maybe this is development environment? Let's check source directory path...";
QString sourceDirPath = STELLARIUM_SOURCE_DIR; // The variable is defined in CMakeLists.txt file
checkFile = QFileInfo(sourceDirPath + QDir::separator() + CHECK_FILE);
if (checkFile.exists())
{
installDir = sourceDirPath;
}
else
{
qWarning() << "WARNING StelFileMgr::StelFileMgr: could not find install location:"
<< QDir::toNativeSeparators(sourceDirPath)
<< " (we checked for "
<< QDir::toNativeSeparators(checkFile.filePath()) << ").";
#ifndef UNIT_TEST
// NOTE: Hook for buildbots (using within testEphemeris)
qFatal("Couldn't find install directory location.");
#endif
}
}
}
}
// Then add the installation directory to the search path
fileLocations.append(installDir);
}
bool PreloadInjector::launch(const QStringList &programAndArgs,
const QString &probeDll,
const QString &probeFunc)
{
Q_UNUSED(probeFunc);
QProcessEnvironment env = QProcessEnvironment::systemEnvironment();
#ifdef Q_OS_MAC
env.insert("DYLD_FORCE_FLAT_NAMESPACE", QLatin1String("1"));
env.insert("DYLD_INSERT_LIBRARIES", probeDll);
env.insert("GAMMARAY_UNSET_DYLD", "1");
#else
env.insert("LD_PRELOAD", probeDll);
env.insert("GAMMARAY_UNSET_PRELOAD", "1");
PreloadCheck check;
bool success = check.test("qt_startup_hook");
if (!success) {
mExitCode = 1;
mErrorString = check.errorString();
return false;
}
#endif
InteractiveProcess proc;
proc.setProcessEnvironment(env);
proc.setProcessChannelMode(QProcess::ForwardedChannels);
QStringList args = programAndArgs;
if (env.value("GAMMARAY_GDB").toInt()) {
QStringList newArgs;
newArgs << "gdb";
#ifndef Q_OS_MAC
newArgs << "--eval-command" << "run";
#endif
newArgs << "--args";
newArgs += args;
args = newArgs;
} else if (env.value("GAMMARAY_MEMCHECK").toInt()) {
QStringList newArgs;
newArgs << "valgrind"
<< "--tool=memcheck"
<< "--track-origins=yes"
<< "--num-callers=25"
<< "--leak-check=full";
newArgs += args;
args = newArgs;
} else if (env.value("GAMMARAY_HELGRIND").toInt()) {
QStringList newArgs;
newArgs << "valgrind" << "--tool=helgrind";
newArgs += args;
args = newArgs;
}
const QString program = args.takeFirst();
proc.start(program, args);
proc.waitForFinished(-1);
mExitCode = proc.exitCode();
mProcessError = proc.error();
mExitStatus = proc.exitStatus();
mErrorString = proc.errorString();
return mExitCode == EXIT_SUCCESS && mExitStatus == QProcess::NormalExit
&& mProcessError == QProcess::UnknownError;
}
void Mapviz::Initialize()
{
if (!initialized_)
{
if (is_standalone_)
{
// If this Mapviz is running as a standalone application, it needs to init
// ROS and start spinning. If it's running as an rqt plugin, rqt will
// take care of that.
ros::init(argc_, argv_, "mapviz", ros::init_options::AnonymousName);
spin_timer_.start(30);
connect(&spin_timer_, SIGNAL(timeout()), this, SLOT(SpinOnce()));
}
node_ = new ros::NodeHandle("~");
// Create a sub-menu that lists all available Image Transports
image_transport::ImageTransport it(*node_);
std::vector<std::string> transports = it.getLoadableTransports();
QActionGroup* group = new QActionGroup(image_transport_menu_);
for (std::vector<std::string>::iterator iter = transports.begin(); iter != transports.end(); iter++)
{
QString transport = QString::fromStdString(*iter).replace(
QString::fromStdString(IMAGE_TRANSPORT_PARAM) + "/", "");
QAction* action = image_transport_menu_->addAction(transport);
action->setCheckable(true);
group->addAction(action);
}
connect(group, SIGNAL(triggered(QAction*)), this, SLOT(SetImageTransport(QAction*)));
tf_ = boost::make_shared<tf::TransformListener>();
tf_manager_ = boost::make_shared<swri_transform_util::TransformManager>();
tf_manager_->Initialize(tf_);
loader_ = new pluginlib::ClassLoader<MapvizPlugin>(
"mapviz", "mapviz::MapvizPlugin");
std::vector<std::string> plugins = loader_->getDeclaredClasses();
for (unsigned int i = 0; i < plugins.size(); i++)
{
ROS_INFO("Found mapviz plugin: %s", plugins[i].c_str());
}
canvas_->InitializeTf(tf_);
canvas_->SetFixedFrame(ui_.fixedframe->currentText().toStdString());
canvas_->SetTargetFrame(ui_.targetframe->currentText().toStdString());
ros::NodeHandle priv("~");
add_display_srv_ = node_->advertiseService("add_mapviz_display", &Mapviz::AddDisplay, this);
QProcessEnvironment env = QProcessEnvironment::systemEnvironment();
QString default_path = QDir::homePath();
if (env.contains(ROS_WORKSPACE_VAR))
{
// If the ROS_WORKSPACE environment variable is defined, try to read our
// config file out of that. If we can't read it, fall back to trying to
// read one from the user's home directory.
QString ws_path = env.value(ROS_WORKSPACE_VAR, default_path);
if (QFileInfo(ws_path + MAPVIZ_CONFIG_FILE).isReadable())
{
default_path = ws_path;
}
else
{
ROS_WARN("Could not load config file from ROS_WORKSPACE at %s; trying home directory...",
ws_path.toStdString().c_str());
}
}
default_path += MAPVIZ_CONFIG_FILE;
std::string config;
priv.param("config", config, default_path.toStdString());
bool auto_save;
priv.param("auto_save_backup", auto_save, true);
Open(config);
UpdateFrames();
frame_timer_.start(1000);
connect(&frame_timer_, SIGNAL(timeout()), this, SLOT(UpdateFrames()));
if (auto_save)
{
save_timer_.start(10000);
connect(&save_timer_, SIGNAL(timeout()), this, SLOT(AutoSave()));
}
connect(&record_timer_, SIGNAL(timeout()), this, SLOT(CaptureVideoFrame()));
bool print_profile_data;
priv.param("print_profile_data", print_profile_data, false);
if (print_profile_data)
{
profile_timer_.start(2000);
connect(&profile_timer_, SIGNAL(timeout()), this, SLOT(HandleProfileTimer()));
}
initialized_ = true;
}
}
/*
* Returns the SHELL environment variable, if not set defaults to sh.
*/
QString UnixCommand::getShell()
{
QProcessEnvironment env = QProcessEnvironment::systemEnvironment();
return env.value("SHELL", "/bin/sh");
}
/*!
* \brief SimMessage::startSimulator simulates the document in view.
*/
void SimMessage::startSimulator()
{
// Using the Doc pointer here is risky as the user may have closed
// the schematic, but converting the SPICE netlists is (hopefully)
// faster than the user (I have no other idea).
QString SimTime;
QStringList Arguments;
QString SimPath = QDir::convertSeparators (QucsSettings.QucsHomeDir.absolutePath());
#ifdef __MINGW32__
QString QucsDigiLib = "qucsdigilib.bat";
QString QucsDigi = "qucsdigi.bat";
QString QucsVeri = "qucsveri.bat";
#else
QString QucsDigiLib = "qucsdigilib";
QString QucsDigi = "qucsdigi";
QString QucsVeri = "qucsveri";
#endif
SimOpt = NULL;
bool isVerilog = false;
QProcessEnvironment env = QProcessEnvironment::systemEnvironment();
// Simulate text window.
if(DocWidget->inherits("QTextEdit")) {
TextDoc * Doc = (TextDoc*)DocWidget;
// Take VHDL file in memory as it could contain unsaved changes.
Stream << Doc->toPlainText();
NetlistFile.close();
ProgText->insertPlainText(tr("done.\n")); // of "creating netlist...
// Simulation.
if (Doc->simulation) {
SimTime = Doc->SimTime;
QString libs = Doc->Libraries.toLower();
/// \todo \bug error: unrecognized command line option '-Wl'
#ifdef __MINGW32__
if(libs.isEmpty()) {
libs = "";
}
else {
libs.replace(" ",",-l");
libs = "-Wl,-l" + libs;
}
#else
if(libs.isEmpty()) {
libs = "-c";
}
else {
libs.replace(" ",",-l");
libs = "-c,-l" + libs;
}
#endif
Program = pathName(QucsSettings.BinDir + QucsDigi);
Arguments << QucsSettings.QucsHomeDir.filePath("netlist.txt")
<< DataSet << SimTime << pathName(SimPath)
<< pathName(QucsSettings.BinDir) << libs;
}
// Module.
else {
QString text = Doc->toPlainText();
VHDL_File_Info VInfo (text);
QString entity = VInfo.EntityName.toLower();
QString lib = Doc->Library.toLower();
if (lib.isEmpty()) lib = "work";
QString dir = QDir::convertSeparators (QucsSettings.QucsHomeDir.path());
QDir vhdlDir(dir);
if(!vhdlDir.exists("vhdl"))
if(!vhdlDir.mkdir("vhdl")) {
ErrText->appendPlainText(tr("ERROR: Cannot create VHDL directory \"%1\"!")
.arg(vhdlDir.path()+"/vhdl"));
return;
}
vhdlDir.setPath(vhdlDir.path()+"/vhdl");
if(!vhdlDir.exists(lib))
if(!vhdlDir.mkdir(lib)) {
ErrText->appendPlainText(tr("ERROR: Cannot create VHDL directory \"%1\"!")
.arg(vhdlDir.path()+"/"+lib));
return;
}
vhdlDir.setPath(vhdlDir.path()+"/"+lib);
QFile destFile;
destFile.setFileName(vhdlDir.filePath(entity+".vhdl"));
if(!destFile.open(QIODevice::WriteOnly)) {
ErrText->appendPlainText(tr("ERROR: Cannot create \"%1\"!")
.arg(destFile.fileName()));
return;
}
destFile.write(text.toAscii(), text.length());
destFile.close();
Program = pathName(QucsSettings.BinDir + QucsDigiLib);
Arguments << QucsSettings.QucsHomeDir.filePath("netlist.txt")
<< pathName(SimPath)
<< entity
<< lib;
}
}
// Simulate schematic window.
else {
// output NodeSets, SPICE simulations etc.
for(QStringList::Iterator it = Collect.begin();
it != Collect.end(); ++it) {
// don't put library includes into netlist...
if ((*it).right(4) != ".lst" &&
(*it).right(5) != ".vhdl" &&
(*it).right(4) != ".vhd" &&
(*it).right(2) != ".v") {
Stream << *it << '\n';
}
}
Stream << '\n';
isVerilog = ((Schematic*)DocWidget)->isVerilog;
SimTime = ((Schematic*)DocWidget)->createNetlist(Stream, SimPorts);
if(SimTime.length()>0&&SimTime.at(0) == '\xA7') {
NetlistFile.close();
ErrText->insertPlainText(SimTime.mid(1));
FinishSimulation(-1);
return;
}
if (isVerilog) {
Stream << "\n"
<< " initial begin\n"
<< " $dumpfile(\"digi.vcd\");\n"
<< " $dumpvars();\n"
<< " #" << SimTime << " $finish;\n"
<< " end\n\n"
<< "endmodule // TestBench\n";
}
NetlistFile.close();
ProgText->insertPlainText(tr("done.\n")); // of "creating netlist...
if(SimPorts < 0) {
// append command arguments
// append netlist with same arguments
if (! Module::vaComponents.isEmpty()) {
/*! Only pass modules to Qucsator that are indeed used on
* the schematic,it might be the case that the user loaded the icons,
* but did not compiled the module. Qucsator will not find the library.
*
* Check if used symbols have corresponing lib before running
* Qucsator? Need to search on the netlis.txt? Is there other data
* structure containig the netlist?
*
*/
QStringList usedComponents;
if (!NetlistFile.open(QIODevice::ReadOnly))
QMessageBox::critical(this, tr("Error"), tr("Cannot read netlist!"));
else {
QString net = QString(NetlistFile.readAll());
QMapIterator<QString, QString> i(Module::vaComponents);
while (i.hasNext()) {
i.next();
if (net.contains(i.key()))
usedComponents << i.key();
}
NetlistFile.close();
}
if (! usedComponents.isEmpty()) {
/// \todo remvoe the command line arguments? use only netlist annotation?
//Arguments << "-p" << QucsSettings.QucsWorkDir.absolutePath()
// << "-m" << usedComponents;
//qDebug() << "Command :" << Program << Arguments.join(" ");
/// Anotate netlist with Verilog-A dynamic path and module names
///
if (!NetlistFile.open(QFile::Append | QFile::Text))
QMessageBox::critical(this, tr("Error"), tr("Cannot read netlist!"));
else {
QTextStream out(&NetlistFile);
out << "\n";
out << "# --path=" << QucsSettings.QucsWorkDir.absolutePath() << "\n";
out << "# --module=" << usedComponents.join(" ") << "\n";
NetlistFile.close();
}
}
} // vaComponents not empty
if((SimOpt = findOptimization((Schematic*)DocWidget))) {
((Optimize_Sim*)SimOpt)->createASCOnetlist();
Program = QucsSettings.AscoBinDir.canonicalPath();
Program = QDir::toNativeSeparators(Program+"/"+"asco"+QString(executableSuffix));
Arguments << "-qucs" << QucsSettings.QucsHomeDir.filePath("asco_netlist.txt")
<< "-o" << "asco_out";
}
else {
Program = QucsSettings.Qucsator;
Arguments << "-b" << "-g" << "-i"
<< QucsSettings.QucsHomeDir.filePath("netlist.txt")
<< "-o" << DataSet;
}
}
else {
if (isVerilog) {
Program = QDir::toNativeSeparators(QucsSettings.BinDir + QucsVeri);
Arguments << QDir::toNativeSeparators(QucsSettings.QucsHomeDir.filePath("netlist.txt"))
<< DataSet
<< SimTime
<< QDir::toNativeSeparators(SimPath)
<< QDir::toNativeSeparators(QucsSettings.BinDir)
<< "-c";
} else {
/// \todo \bug error: unrecognized command line option '-Wl'
#ifdef __MINGW32__
Program = QDir::toNativeSeparators(pathName(QucsSettings.BinDir + QucsDigi));
Arguments << QDir::toNativeSeparators(QucsSettings.QucsHomeDir.filePath("netlist.txt"))
<< DataSet
<< SimTime
<< QDir::toNativeSeparators(SimPath)
<< QDir::toNativeSeparators(QucsSettings.BinDir) << "-Wall" << "-c";
#else
Program = QDir::toNativeSeparators(pathName(QucsSettings.BinDir + QucsDigi));
Arguments << QucsSettings.QucsHomeDir.filePath("netlist.txt")
<< DataSet << SimTime << pathName(SimPath)
<< pathName(QucsSettings.BinDir) << "-Wall" << "-c";
#endif
}
}
}
disconnect(&SimProcess, 0, 0, 0);
connect(&SimProcess, SIGNAL(readyReadStandardError()), SLOT(slotDisplayErr()));
connect(&SimProcess, SIGNAL(readyReadStandardOutput()), SLOT(slotDisplayMsg()));
connect(&SimProcess, SIGNAL(finished(int, QProcess::ExitStatus)),
SLOT(slotSimEnded(int, QProcess::ExitStatus)));
connect(&SimProcess, SIGNAL(stateChanged(QProcess::ProcessState)),
SLOT(slotStateChanged(QProcess::ProcessState)));
#ifdef SPEEDUP_PROGRESSBAR
waitForUpdate = false;
#endif
wasLF = false;
ProgressText = "";
#ifdef __MINGW32__
QString sep(";"); // path separator
#else
QString sep(":");
#endif
// append process PATH
// insert Qucs bin dir, so ASCO can find qucsator
env.insert("PATH", env.value("PATH") + sep + QucsSettings.BinDir );
SimProcess.setProcessEnvironment(env);
qDebug() << "Command :" << Program << Arguments.join(" ");
SimProcess.start(Program, Arguments); // launch the program
}
continue;
}
name = QStandardPaths::displayName(i);
path.replace(" ", "\\ ");
cmd = "cd " + path;
addChild(new BookmarkCommandItem(name, cmd, this));
}
#endif
// system env - include dirs in the tree
QProcessEnvironment env = QProcessEnvironment::systemEnvironment();
foreach (QString i, env.keys())
{
path = env.value(i);
if (!d.exists(path) || !QFileInfo(path).isDir())
{
//qDebug() << "Env Dir:" << path << "does not exist. Skipping.";
continue;
}
path.replace(" ", "\\ ");
cmd = "cd " + path;
addChild(new BookmarkCommandItem(i, cmd, this));
}
}
};
class BookmarkFileGroupItem : public BookmarkGroupItem
{
// hierarchy handling
QString OpenModelica::home()
{
QProcessEnvironment env = QProcessEnvironment::systemEnvironment();
QString omHome = env.value("OpenModelicaHome");
return omHome;
}
// Next parts of code are tested with VLC media player 2.1.2 and later with 2.1.5 Rincewind on Linux.
// On windows it's disabled because the console interface of VLC on windows is broken.
// Once they (videolan.org) has fixed this, we can test it and hopefully enable it on windows too.
void UI_Mainwindow::start_stop_video()
{
if(video_player->status != VIDEO_STATUS_STOPPED)
{
stop_video_generic();
return;
}
if(playback_realtime_active)
{
return;
}
if(live_stream_active)
{
QMessageBox messagewindow(QMessageBox::Critical, "Error", "Can not open a video during a live stream.");
messagewindow.exec();
return;
}
if(video_player->status != VIDEO_STATUS_STOPPED)
{
QMessageBox messagewindow(QMessageBox::Critical, "Error", "There is already a video running.");
messagewindow.exec();
return;
}
if(signalcomps < 1)
{
QMessageBox messagewindow(QMessageBox::Critical, "Error", "Put some signals on the screen first.");
messagewindow.exec();
return;
}
if(annot_editor_active)
{
QMessageBox messagewindow(QMessageBox::Critical, "Error", "Close the annotation editor first.");
messagewindow.exec();
return;
}
strcpy(videopath, QFileDialog::getOpenFileName(this, "Select video", QString::fromLocal8Bit(recent_opendir),
"Video files (*.ogv *.OGV *.ogg *.OGG *.mkv *.MKV *.avi *.AVI"
" *.mp4 *.MP4 *.mpeg *.MPEG *.mpg *.MPG *.wmv *.WMV)").toLocal8Bit().data());
if(!strcmp(videopath, ""))
{
return;
}
get_directory_from_path(recent_opendir, videopath, MAX_PATH_LENGTH);
video_player->utc_starttime = parse_date_time_stamp(videopath);
if(video_player->utc_starttime < 0LL)
{
QMessageBox messagewindow(QMessageBox::Warning, "Warning", "Unable to get startdate and starttime from video filename.\n"
" \nAssume video starttime equals EDF/BDF starttime?\n ");
messagewindow.setStandardButtons(QMessageBox::Yes | QMessageBox::Cancel);
messagewindow.setDefaultButton(QMessageBox::Yes);
if(messagewindow.exec() == QMessageBox::Cancel) return;
video_player->utc_starttime = edfheaderlist[sel_viewtime]->utc_starttime;
}
video_player->stop_det_counter = 0;
video_player->fpos = 0;
video_player->starttime_diff = (int)(edfheaderlist[sel_viewtime]->utc_starttime - video_player->utc_starttime);
if((edfheaderlist[sel_viewtime]->utc_starttime + edfheaderlist[sel_viewtime]->recording_len_sec) < video_player->utc_starttime)
{
QMessageBox messagewindow(QMessageBox::Critical, "Error", "The video registration and the EDF/BDF registration do not overlap (in time)!");
messagewindow.exec();
return;
}
if((video_player->utc_starttime + 259200LL) < edfheaderlist[sel_viewtime]->utc_starttime)
{
QMessageBox messagewindow(QMessageBox::Critical, "Error", "The video registration and the EDF/BDF registration do not overlap (in time)!");
messagewindow.exec();
return;
}
video_process = new QProcess(this);
#ifdef Q_OS_WIN32
QProcessEnvironment env = QProcessEnvironment::systemEnvironment();
env.insert("PATH", env.value("PATH") + ";C:\\Program Files\\VideoLAN\\VLC");
video_process->setProcessEnvironment(env);
#endif
connect(video_process, SIGNAL(error(QProcess::ProcessError)), this, SLOT(video_process_error(QProcess::ProcessError)));
QStringList arguments;
arguments << "--video-on-top" << "-I" << "rc";
video_process->start("vlc", arguments);
if(video_process->waitForStarted(5000) == false)
{
QMessageBox messagewindow(QMessageBox::Critical, "Error", "Unable to start VLC mediaplayer.\n"
"Check your installation of VLC.\n"
"Also, check if VLC is present in the PATH evironment variable.");
messagewindow.exec();
return;
}
#ifdef DEBUG_VIDEOPLAYER
debug_vpr = fopen("debug_vpr.txt", "wb");
#endif
video_player->status = VIDEO_STATUS_STARTUP_1;
video_player->poll_timer = 100;
video_player->cntdwn_timer = 5000;
video_poll_timer->start(video_player->poll_timer);
video_act->setText("Stop video");
}
bool HttpServer::initialize()
{
if(m_IsInitialized)
{
LOG_DEBUG("Already initialized");
return false;
}
QProcessEnvironment env = QProcessEnvironment::systemEnvironment();
if(env.contains(QTTP_HOME_ENV_VAR))
{
QDir::setCurrent(env.value(QTTP_HOME_ENV_VAR));
LOG_DEBUG("Working directory from $" << QTTP_HOME_ENV_VAR << QDir::currentPath());
}
else
{
// Just a quirk for mac, but I wonder if we can apply to all in general.
#ifdef Q_OS_MAC
QDir::setCurrent(qApp->applicationDirPath());
LOG_DEBUG("Working directory" << QDir::currentPath());
#else
LOG_DEBUG("Working directory" << QDir::currentPath());
#endif
}
QCoreApplication* app = QCoreApplication::instance();
Q_ASSERT(app);
m_CmdLineParser.addOptions({
{{"i", "ip"},
QCoreApplication::translate("main", "ip of the target interface"),
QCoreApplication::translate("main", "ip")},
{{"p", "port"},
QCoreApplication::translate("main", "port to listen on"),
QCoreApplication::translate("main", "port")},
{{"m", "meta"},
QCoreApplication::translate("main", "appends metadata to responses")},
{{"c", "config"},
QCoreApplication::translate("main", "absolute path to the global config file (json)"),
QCoreApplication::translate("main", "config")},
{{"r", "routes"},
QCoreApplication::translate("main", "absolute path to the routes config file (json)"),
QCoreApplication::translate("main", "routes")},
{{"d", "dir"},
QCoreApplication::translate("main", "absolute path to the config directory, don't combine with -c or -r args"),
QCoreApplication::translate("main", "dir")},
{{"w", "www"},
QCoreApplication::translate("main", "absolute path to the www folder to serve http files"),
QCoreApplication::translate("main", "www")},
{{"s", "swagger"},
QCoreApplication::translate("main", "exposes swagger-api json responses for the path /swagger/")},
});
m_CmdLineParser.addHelpOption();
m_CmdLineParser.process(*app);
if(env.contains(CONFIG_DIRECTORY_ENV_VAR))
{
QString var = env.value(CONFIG_DIRECTORY_ENV_VAR);
if(!var.isNull() && !var.trimmed().isEmpty())
{
LOG_INFO("Processing ENVIRONMENT VARIABLE [" << var << "]");
initConfigDirectory(var);
}
else
{
LOG_WARN("Invalid ENVIRONMENT VARIABLE [" << CONFIG_DIRECTORY_ENV_VAR << "]");
}
}
QJsonValue d = m_CmdLineParser.value("d");
if(d.isString() && !d.isNull() && !d.toString().trimmed().isEmpty())
{
initConfigDirectory(d.toString());
}
else
{
QJsonValue c = m_CmdLineParser.value("c");
if(c.isString() && !c.isNull() && !c.toString().trimmed().isEmpty())
{
initGlobal(c.toString());
}
else
{
initGlobal(GLOBAL_CONFIG_FILE_PATH);
}
QJsonValue r = m_CmdLineParser.value("r");
if(r.isString() && !r.isNull() && !r.toString().trimmed().isEmpty())
{
initRoutes(r.toString());
}
else
{
initRoutes(ROUTES_CONFIG_FILE_PATH);
}
}
if(!m_SendRequestMetadata)
{
m_SendRequestMetadata = m_CmdLineParser.isSet("m");
LOG_DEBUG("CmdLine meta-data" << m_SendRequestMetadata);
}
if(!m_IsSwaggerEnabled)
{
initSwagger(m_CmdLineParser.isSet("s"));
LOG_DEBUG("CmdLine swagger" << m_IsSwaggerEnabled);
}
QJsonValue i = m_CmdLineParser.value("i");
if((i.isString() || i.isDouble()) && !i.toString().trimmed().isEmpty())
{
QString ip = i.toString();
m_GlobalConfig["bindIp"] = ip;
LOG_DEBUG("CmdLine ip" << ip);
}
QJsonValue p = m_CmdLineParser.value("p");
if((p.isString() || p.isDouble()) && !p.toString().trimmed().isEmpty())
{
qint32 port = p.toInt();
m_GlobalConfig["bindPort"] = port;
LOG_DEBUG("CmdLine port" << port);
}
QJsonValue w = m_CmdLineParser.value("w");
if(w.isString() && !w.isNull() && !w.toString().trimmed().isEmpty())
{
initHttpDirectory(w.toString());
LOG_DEBUG("CmdLine www/web/http-files" << w);
}
m_IsInitialized = true;
return true;
}
void HttpServer::initGlobal(const QString &filepath)
{
LOG_INFO("Processing filepath [" << filepath << "]");
m_GlobalConfig = Utils::readJson(QDir(filepath).absolutePath());
LOG_INFO(m_GlobalConfig["bindIp"]);
LOG_INFO(m_GlobalConfig["bindPort"]);
QJsonValueRef loggingValue = m_GlobalConfig["logfile"];
if(loggingValue.isObject())
{
QJsonObject logging = loggingValue.toObject();
if(logging["isEnabled"].toBool(true))
{
QString filename;
if(logging["filename"].isString())
{
filename = logging["filename"].toString();
}
if(logging["writeFrequency"].isDouble())
{
m_LoggingUtils.initializeFile(filename, logging["writeFrequency"].toInt());
}
else
{
m_LoggingUtils.initializeFile(filename);
}
}
}
QJsonValueRef httpFilesValue = m_GlobalConfig["httpFiles"];
if(httpFilesValue.isObject())
{
QJsonObject httpFiles = httpFilesValue.toObject();
m_ShouldServeFiles = httpFiles["isEnabled"].toBool(false);
if(m_ShouldServeFiles)
{
QString directory = httpFiles["directory"].toString().trimmed();
if(directory == "$QTTP_HOME")
{
QProcessEnvironment env = QProcessEnvironment::systemEnvironment();
if(env.contains(QTTP_HOME_ENV_VAR))
{
m_ServeFilesDirectory = QDir::cleanPath(env.value(QTTP_HOME_ENV_VAR));
m_ServeFilesDirectory = m_ServeFilesDirectory.absoluteFilePath("www");
LOG_DEBUG("Using $QTTP_HOME" << m_ServeFilesDirectory.absolutePath());
}
else
{
m_ServeFilesDirectory = QDir::current().absoluteFilePath("www");
LOG_DEBUG("QTTP_HOME not found, using current directory" << m_ServeFilesDirectory.absolutePath());
}
}
else if(directory.isEmpty())
{
m_ServeFilesDirectory = QDir::current().absoluteFilePath("www");
LOG_DEBUG("Default to using current directory" << m_ServeFilesDirectory.absolutePath());
}
else
{
m_ServeFilesDirectory = QDir::cleanPath(directory);
LOG_DEBUG("Using directory in config" << m_ServeFilesDirectory.absolutePath());
}
if(!m_ServeFilesDirectory.exists())
{
LOG_ERROR("Unable to serve files from invalid directory [" << m_ServeFilesDirectory.absolutePath() << "]");
m_ShouldServeFiles = false;
}
}
}
if(m_ShouldServeFiles)
{
m_FileLookup.populateFiles(m_ServeFilesDirectory);
}
QJsonObject headers = m_GlobalConfig["defaultHeaders"].toObject();
QStringList keys = headers.keys();
if(!keys.isEmpty())
{
Global::DEFAULT_HEADERS.clear();
for(QString key : keys)
{
QString value = headers.value(key).toString();
Global::DEFAULT_HEADERS.push_back({ key, value });
LOG_DEBUG("Adding default-header [" << key << ", " << value << "]");
}
// We'll always force the QttpServer version in here.
Global::DEFAULT_HEADERS.push_back({ "Server", QTTP_SERVER_VERSION });
}
else
{
LOG_DEBUG("Did not read headers in config file, using default headers");
}
QJsonObject serverConfig = m_GlobalConfig["server"].toObject();
m_SendRequestMetadata = serverConfig["metadata"].toBool(false);
m_StrictHttpMethod = serverConfig["strictHttpMethod"].toBool(false);
QJsonObject processors = serverConfig["processors"].toObject();
keys = processors.keys();
for(QString key : keys)
{
bool isEnabled = processors.value(key).toBool(false);
LOG_DEBUG("Processor [" << key << "] is " <<
(isEnabled ? "ENABLED" : "NOT ENABLED"));
if(isEnabled)
{
m_EnabledProcessors.append(key);
}
}
QJsonObject swagger = m_GlobalConfig["swagger"].toObject();
initSwagger(swagger["isEnabled"].toBool(false));
#ifndef ASSIGN_SWAGGER
# define ASSIGN_SWAGER(X) m_ServerInfo.X = swagger[#X].toString()
#endif
ASSIGN_SWAGER(host);
ASSIGN_SWAGER(basePath);
ASSIGN_SWAGER(version);
ASSIGN_SWAGER(title);
ASSIGN_SWAGER(description);
ASSIGN_SWAGER(termsOfService);
QJsonObject company = swagger["company"].toObject();
m_ServerInfo.companyName = company["name"].toString();
m_ServerInfo.companyUrl = company["url"].toString();
QJsonObject contact = swagger["contact"].toObject();
m_ServerInfo.contactEmail = contact["email"].toString();
QJsonObject license = swagger["license"].toObject();
m_ServerInfo.licenseName = license["name"].toString();
m_ServerInfo.licenseUrl = license["url"].toString();
m_ServerInfo.schemes = swagger["schemes"].toArray();
m_ServerInfo.consumes = swagger["consumes"].toArray();
m_ServerInfo.produces = swagger["produces"].toArray();
}
int main(int argc, char *argv[])
{
#if QT_VERSION < 0x050000
// The GraphicsSystem needs to be set before the instantiation of the
// QApplication. Therefore we need to parse the current setting
// in this unusual place :-/
QSettings graphicsSettings("KDE", "Marble Virtual Globe"); // keep the parameters here
QString const graphicsString = graphicsSettings.value("View/graphicsSystem", "raster").toString();
QApplication::setGraphicsSystem( graphicsString );
#endif
QApplication app(argc, argv);
app.setApplicationName( "Marble Virtual Globe" );
app.setOrganizationName( "KDE" );
app.setOrganizationDomain( "kde.org" );
// Widget translation
#ifdef Q_WS_MAEMO_5
// Work around http://bugreports.qt-project.org/browse/QTBUG-1313
QProcessEnvironment env = QProcessEnvironment::systemEnvironment();
QString lang( "C" );
QStringList const locales = QStringList() << "LC_ALL" << "LC_MESSAGES" << "LANG" << "LANGUAGE";
foreach( const QString &locale, locales ) {
if ( env.contains( locale ) && !env.value( locale ).isEmpty() ) {
lang = env.value( locale, "C" );
break;
}
}
lang = lang.section( '_', 0, 0 );
#else
QString lang = QLocale::system().name().section('_', 0, 0);
#endif
QTranslator translator;
translator.load( "marble-" + lang, MarbleDirs::path(QString("lang") ) );
app.installTranslator(&translator);
// For non static builds on mac and win
// we need to be sure we can find the qt image
// plugins. In mac be sure to look in the
// application bundle...
#ifdef Q_WS_WIN
QApplication::addLibraryPath( QApplication::applicationDirPath()
+ QDir::separator() + "plugins" );
#endif
#ifdef Q_OS_MACX
QApplication::instance()->setAttribute(Qt::AA_DontShowIconsInMenus);
qDebug("Adding qt image plugins to plugin search path...");
CFURLRef myBundleRef = CFBundleCopyBundleURL(CFBundleGetMainBundle());
CFStringRef myMacPath = CFURLCopyFileSystemPath(myBundleRef, kCFURLPOSIXPathStyle);
const char *mypPathPtr = CFStringGetCStringPtr(myMacPath,CFStringGetSystemEncoding());
CFRelease(myBundleRef);
CFRelease(myMacPath);
QString myPath(mypPathPtr);
// if we are not in a bundle assume that the app is built
// as a non bundle app and that image plugins will be
// in system Qt frameworks. If the app is a bundle
// lets try to set the qt plugin search path...
if (myPath.contains(".app"))
{
myPath += "/Contents/plugins";
QApplication::addLibraryPath( myPath );
qDebug( "Added %s to plugin search path", qPrintable( myPath ) );
}
#endif
QString marbleDataPath;
int dataPathIndex=0;
QString mapThemeId;
QString coordinatesString;
QString distanceString;
const MarbleGlobal::Profiles profiles = MarbleGlobal::SmallScreen | MarbleGlobal::HighResolution;
QStringList args = QApplication::arguments();
if ( args.contains( "-h" ) || args.contains( "--help" ) ) {
qWarning() << "Usage: marble [options] [files]";
qWarning();
qWarning() << "[files] can be zero, one or more .kml and/or .gpx files to load and show.";
qWarning();
qWarning() << "general options:";
qWarning() << " --marbledatapath=<path> .... Overwrite the compile-time path to map themes and other data";
qWarning() << " --latlon=<coordinates> ..... Show map at given lat lon coordinates";
qWarning() << " --distance=<value> ......... Set the distance of the observer to the globe (in km)";
qWarning() << " --map=<id> ................. Use map id (e.g. \"earth/openstreetmap/openstreetmap.dgml\")";
qWarning();
qWarning() << "debug options:";
qWarning() << " --debug-info ............... write (more) debugging information to the console";
qWarning() << " --fps ...................... Show the paint performance (paint rate) in the top left corner";
qWarning() << " --runtimeTrace.............. Show the time spent and other debug info of each layer";
qWarning() << " --tile-id................... Write the identifier of texture tiles on top of them";
qWarning() << " --timedemo ................. Measure the paint performance while moving the map and quit";
return 0;
}
for ( int i = 1; i < args.count(); ++i ) {
const QString arg = args.at(i);
if ( arg == QLatin1String( "--debug-info" ) )
{
MarbleDebug::setEnabled( true );
}
else if ( arg.startsWith( QLatin1String( "--marbledatapath=" ), Qt::CaseInsensitive ) )
{
marbleDataPath = args.at(i).mid(17);
}
else if ( arg.compare( QLatin1String( "--marbledatapath" ), Qt::CaseInsensitive ) == 0 ) {
dataPathIndex = i + 1;
marbleDataPath = args.value( dataPathIndex );
++i;
}
else if ( arg.startsWith( QLatin1String( "--latlon=" ), Qt::CaseInsensitive ) )
{
coordinatesString = arg.mid(9);
}
else if ( arg.compare( QLatin1String( "--latlon" ), Qt::CaseInsensitive ) == 0 ) {
++i;
// TODO: misses an error check if there is a value at all
// and error reporting to user (problem also exists with marbledatapath)
coordinatesString = args.value( i );
}
else if ( arg.startsWith( QLatin1String( "--distance=" ), Qt::CaseInsensitive ) )
{
distanceString = arg.mid(11);
}
else if ( arg.compare( QLatin1String( "--distance" ), Qt::CaseInsensitive ) == 0 ) {
++i;
// TODO: misses an error check if there is a value at all
// and error reporting to user (problem also exists with marbledatapath)
distanceString = args.value( i );
}
else if ( arg.startsWith( QLatin1String( "--map=" ), Qt::CaseInsensitive ) )
{
mapThemeId = arg.mid(6);
}
else if ( arg.compare( QLatin1String( "--map" ), Qt::CaseInsensitive ) == 0 ) {
++i;
// TODO: misses an error check if there is a value at all
// and error reporting to user (problem also exists with marbledatapath)
mapThemeId = args.value( i );
}
}
MarbleGlobal::getInstance()->setProfiles( profiles );
QLocale::MeasurementSystem const measurement = QLocale::system().measurementSystem();
MarbleGlobal::getInstance()->locale()->setMeasurementSystem( measurement );
QVariantMap cmdLineSettings;
if ( !mapThemeId.isEmpty() ) {
cmdLineSettings.insert( QLatin1String("mapTheme"), QVariant(mapThemeId) );
}
if ( !coordinatesString.isEmpty() ) {
bool success = false;
const GeoDataCoordinates coordinates = GeoDataCoordinates::fromString(coordinatesString, success);
if ( success ) {
QVariantList lonLat;
lonLat << QVariant( coordinates.longitude(GeoDataCoordinates::Degree) )
<< QVariant( coordinates.latitude(GeoDataCoordinates::Degree) );
cmdLineSettings.insert( QLatin1String("lonlat"), QVariant(lonLat) );
}
}
if ( !distanceString.isEmpty() ) {
bool success = false;
const qreal distance = distanceString.toDouble(&success);
if ( success ) {
cmdLineSettings.insert( QLatin1String("distance"), QVariant(distance) );
}
}
MainWindow *window = new MainWindow( marbleDataPath, cmdLineSettings );
window->setAttribute( Qt::WA_DeleteOnClose, true );
// window->marbleWidget()->rotateTo( 0, 0, -90 );
// window->show();
for ( int i = 1; i < args.count(); ++i ) {
const QString arg = args.at(i);
if ( arg == "--timedemo" )
{
window->resize(900, 640);
MarbleTest marbleTest( window->marbleWidget() );
marbleTest.timeDemo();
return 0;
}
else if( arg == "--fps" ) {
window->marbleWidget()->setShowFrameRate( true );
}
else if ( arg == "--tile-id" )
{
window->marbleWidget()->setShowTileId(true);
}
else if( arg == "--runtimeTrace" ) {
window->marbleWidget()->setShowRuntimeTrace( true );
}
else if ( i != dataPathIndex && QFile::exists( arg ) ) {
window->addGeoDataFile( QFileInfo( arg ).absoluteFilePath() );
}
}
return app.exec();
}
/**
* Get the path to the users home directory.
* @return
*/
QString Credentials::usersHomePath()
{
QProcessEnvironment env = QProcessEnvironment::systemEnvironment();
return env.value(QString("HOME"));
}
// -------------------------------------------------------------------------
bool SpiceFile::recreateSubNetlist(QString *SpiceFile, QString *FileName)
{
// initialize collectors
ErrText = "";
NetText = "";
SimText = "";
NetLine = "";
// evaluate properties
if(Props.at(1)->Value != "")
makeSubcircuit = true;
else
makeSubcircuit = false;
if(Props.at(2)->Value == "yes")
insertSim = true;
else
insertSim = false;
// preprocessor run if necessary
QString preprocessor = Props.at(3)->Value;
if (preprocessor != "none") {
bool piping = true;
QStringList script;
#ifdef __MINGW32__
QString interpreter = "tinyperl.exe";
#else
QString interpreter = "perl";
#endif
if (preprocessor == "ps2sp") {
script << "ps2sp";
} else if (preprocessor == "spicepp") {
script << "spicepp.pl";
} else if (preprocessor == "spiceprm") {
script << "spiceprm";
piping = false;
}
SpicePrep = new QProcess(this);
script << interpreter;
script << script;
script << *SpiceFile;
QFile PrepFile;
QString PrepName = *SpiceFile + ".pre";
if (!piping) {
script << PrepName;
connect(SpicePrep, SIGNAL(readyReadStandardOutput()), SLOT(slotSkipOut()));
connect(SpicePrep, SIGNAL(readyReadStandardError()), SLOT(slotGetPrepErr()));
} else {
connect(SpicePrep, SIGNAL(readyReadStandardOutput()), SLOT(slotGetPrepOut()));
connect(SpicePrep, SIGNAL(readyReadStandardError()), SLOT(slotGetPrepErr()));
}
QMessageBox *MBox =
new QMessageBox(QMessageBox::NoIcon,
QObject::tr("Info"),
QObject::tr("Preprocessing SPICE file \"%1\".").arg(*SpiceFile),
QMessageBox::Abort);
MBox->setAttribute(Qt::WA_DeleteOnClose);
connect(SpicePrep, SIGNAL(finished(int)), MBox, SLOT(close()));
if (piping) {
PrepFile.setFileName(PrepName);
if(!PrepFile.open(QIODevice::WriteOnly)) {
ErrText +=
QObject::tr("ERROR: Cannot save preprocessed SPICE file \"%1\".").
arg(PrepName);
return false;
}
prestream = new QTextStream(&PrepFile);
}
QProcessEnvironment env = QProcessEnvironment::systemEnvironment();
env.insert("PATH", env.value("PATH") );
SpicePrep->setProcessEnvironment(env);
SpicePrep->start(script.join(" "));
//QucsHelp->setCommunication(0);
if(SpicePrep->state()!=QProcess::Running&&
SpicePrep->state()!=QProcess::Starting) {
ErrText += QObject::tr("ERROR: Cannot execute \"%1\".").
arg(interpreter + " " + script.join(" ") + "\".");
if (piping) {
PrepFile.close();
delete prestream;
}
return false;
}
//SpicePrep->closeStdin();
MBox->exec();
delete SpicePrep;
if (piping) {
PrepFile.close();
delete prestream;
}
*SpiceFile = PrepName;
}
// begin command line construction
QString prog;
QStringList com;
//prog = QucsSettings.BinDir + "qucsconv" + executableSuffix;
prog = QucsSettings.Qucsconv;
if(makeSubcircuit) com << "-g" << "_ref";
com << "-if" << "spice" << "-of" << "qucs";
com << "-i" << *SpiceFile;
// begin netlist text creation
if(makeSubcircuit) {
QString f = misc::properFileName(*FileName);
NetText += "\n.Def:" + misc::properName(f) + " ";
QString PortNames = Props.at(1)->Value;
PortNames.replace(',', ' ');
NetText += PortNames;
if(makeSubcircuit) NetText += " _ref";
}
NetText += "\n";
// startup SPICE conversion process
QucsConv = new QProcess(this);
QProcessEnvironment env = QProcessEnvironment::systemEnvironment();
env.insert("PATH", env.value("PATH") );
QucsConv->setProcessEnvironment(env);
qDebug() << "SpiceFile::recreateSubNetlist :Command:" << prog << com.join(" ");
// QucsConv->start(com.join(" "));
QucsConv->start(prog, com);
/// these slots might write into NetText, ErrText, outstream, filstream
connect(QucsConv, SIGNAL(readyReadStandardOutput()), SLOT(slotGetNetlist()));
connect(QucsConv, SIGNAL(readyReadStandardError()), SLOT(slotGetError()));
connect(QucsConv, SIGNAL(finished(int,QProcess::ExitStatus)), SLOT(slotExited()));
if(QucsConv->state()!=QProcess::Running&&
QucsConv->state()!=QProcess::Starting) {
ErrText += QObject::tr("COMP ERROR: Cannot start QucsConv!");
return false;
}
(*outstream) << NetText;
(*filstream) << NetText;
// only interact with the GUI if it was launched
if (QucsMain) {
QucsMain->statusBar()->showMessage(tr("Converting SPICE file \"%1\".").arg(*SpiceFile), 2000);
}
else
qDebug() << QObject::tr("Converting SPICE file \"%1\".").arg(*SpiceFile);
// finish
QucsConv->waitForFinished();
delete QucsConv;
lastLoaded = QDateTime::currentDateTime();
return true;
}
void IDLBuilder::build(const QString& installDir, const QStringList& files)
{
int step = 0;
// Step 0 - TODO check input files
emit progress(step++);
// Random job name
const QString jobName(
QDateTime::currentDateTime().toString("YYYYMMDDhhmmsszzz"));
const QString workingDir = m_tmpDir + jobName;
const QString buildDir = workingDir + "/build";
m_fs.mkdir(workingDir, true);
m_fs.mkdir(buildDir, true);
// Step 1 - IDL Compilation
QProcess corbasim_make;
corbasim_make.setWorkingDirectory(workingDir);
QProcessEnvironment env = QProcessEnvironment::systemEnvironment();
env.insert("PATH",
QCoreApplication::applicationDirPath() + ":" +
env.value("PATH"));
corbasim_make.setProcessEnvironment(env);
corbasim_make.start("corbasim_make",
QStringList() << "-n" << jobName << files);
if (!corbasim_make.waitForStarted())
{
emit error("C++ files generation error!");
return;
}
corbasim_make.waitForFinished(-1);
emit progress(step++);
// Step 2 - Create compilation cache
QProcess cmake;
QStringList cmakeOptions;
cmake.setWorkingDirectory(buildDir);
cmakeOptions << "-DCMAKE_BUILD_TYPE=Release";
cmakeOptions << QString("-DCMAKE_INSTALL_PREFIX=") + installDir;
cmakeOptions << "..";
cmake.start("cmake", cmakeOptions);
cmake.waitForFinished(-1);
emit progress(step++);
// Step 3 - Compiling
QProcess make;
make.setWorkingDirectory(buildDir);
make.start("make");
make.waitForFinished(-1);
emit progress(step++);
// Step 4 - Installing
QProcess install;
install.setWorkingDirectory(buildDir);
install.start("make", QStringList() << "install");
install.waitForFinished(-1);
emit progress(step++);
}