bool consoleApplication(QCoreApplication *pApp, int *pRes)
{
*pRes = 0; // By default, everything is fine
// Specify the type of command line options that are allowed
// Note #1: we don't rely on the QxtCommandOptions::showUsage() method
// Note #2: we don't distinguish between Windows and Linux / OS X when it
// comes to the formatting of the command line options
QxtCommandOptions cmdLineOptions;
cmdLineOptions.setFlagStyle(QxtCommandOptions::DoubleDash);
cmdLineOptions.setParamStyle(QxtCommandOptions::SpaceAndEquals);
cmdLineOptions.add("help");
cmdLineOptions.alias("help", "h");
cmdLineOptions.add("about");
cmdLineOptions.alias("about", "a");
cmdLineOptions.add("version");
cmdLineOptions.alias("version", "v");
// Parse the command line options
cmdLineOptions.parse(pApp->arguments());
// See what needs doing with the command line options, if anything
if (cmdLineOptions.count("help")) {
// The user wants to know how to use OpenCOR from the console, so...
usage(pApp);
return true;
}
else if (cmdLineOptions.count("about")) {
// The user wants to know how to use OpenCOR from the console, so...
about(pApp);
return true;
} else if (cmdLineOptions.count("version")) {
// The user wants to know the version of OpenCOR this is, so...
version(pApp);
return true;
} else if (cmdLineOptions.getUnrecognizedWarning().count()) {
// The user provided OpenCOR with wrong command line options, so...
usage(pApp);
*pRes = -1;
return true;
} else {
// The user didn't provide any command line options that requires
// running OpenCOR as a console application, so...
return false;
}
}
int main(int argc, char **argv)
{
#if (QT_VERSION < 0x050200)
#error("You need Qt 5.2.0 or later to compile Actiona Executer");
#endif
#if (QT_VERSION >= QT_VERSION_CHECK(5, 0, 0))
QtSingleApplication app("actiona-exec", argc, argv);
#else
ActionTools::NativeEventFilteringApplication app("actiona-exec", argc, argv);
#endif
app.setQuitOnLastWindowClosed(false);
qAddPostRoutine(cleanup);
qsrand(std::time(NULL));
#ifdef Q_OS_LINUX
notify_init("Actiona executer");
#endif
#if (QT_VERSION < QT_VERSION_CHECK(5, 0, 0))
QTextCodec::setCodecForTr(QTextCodec::codecForName("UTF-8"));
#endif
QxtCommandOptions preOptions;
preOptions.add("portable", QObject::tr("starts in portable mode, storing the settings in the executable folder"));
preOptions.alias("portable", "p");
preOptions.parse(QCoreApplication::arguments());
if(preOptions.count("portable") > 0)
{
QSettings::setPath(QSettings::IniFormat, QSettings::UserScope, QApplication::applicationDirPath() + "/userSettings");
QSettings::setPath(QSettings::IniFormat, QSettings::SystemScope, QApplication::applicationDirPath() + "/systemSettings");
QSettings::setDefaultFormat(QSettings::IniFormat);
}
QString locale = Tools::locale();
Tools::installQtTranslator(locale);
Tools::installTranslator("tools", locale);
Tools::installTranslator("actiontools", locale);
Tools::installTranslator("executer", locale);
Tools::installTranslator("actexecuter", locale);
const QStringList &arguments = QCoreApplication::arguments();
QxtCommandOptions options;
options.setFlagStyle(QxtCommandOptions::DoubleDash);
options.setScreenWidth(0);
options.add("code", QObject::tr("switch to code mode, may not be used with -s"));
options.alias("code", "c");
options.add("script", QObject::tr("switch to script mode, may not be used with -c"));
options.alias("script", "s");
options.add("nocodeqt", QObject::tr("do not include the Qt library into the code"));
options.alias("nocodeqt", "Q");
options.add("portable", QObject::tr("starts in portable mode, storing the settings in the executable folder"));
options.alias("portable", "p");
options.add("proxy-mode", QObject::tr("sets the proxy mode, values are \"none\", \"system\" (default) or \"custom\""));
options.add("proxy-type", QObject::tr("sets the custom proxy type, values are \"http\" or \"socks\" (default)"));
options.add("proxy-host", QObject::tr("sets the custom proxy host"));
options.add("proxy-port", QObject::tr("sets the custom proxy port"));
options.add("proxy-user", QObject::tr("sets the custom proxy user"));
options.add("proxy-password", QObject::tr("sets the custom proxy password"));
#ifdef Q_OS_WIN
options.add("console", QObject::tr("create a console to see debug output"));
options.add("pause-at-end", QObject::tr("wait for user input at the end of the execution, used only with --console"));
#endif
options.add("version", QObject::tr("show the program version"));
options.alias("version", "v");
options.add("help", QObject::tr("show this help text"));
options.alias("help", "h");
options.parse(arguments);
#ifdef Q_OS_WIN
if(options.count("console"))
{
createConsole();
if(options.count("pause-at-end"))
qAddPostRoutine(pause);
}
#endif
qRegisterMetaType<ActionTools::ActionInstance>("ActionInstance");
qRegisterMetaType<ActionTools::ActionException::Exception>("Exception");
qRegisterMetaType<ActionTools::Parameter>("Parameter");
qRegisterMetaType<ActionTools::SubParameter>("SubParameter");
qRegisterMetaType<Tools::Version>("Version");
qRegisterMetaTypeStreamOperators<ActionTools::ActionInstance>("ActionInstance");
qRegisterMetaTypeStreamOperators<ActionTools::Parameter>("Parameter");
qRegisterMetaTypeStreamOperators<ActionTools::SubParameter>("SubParameter");
qRegisterMetaTypeStreamOperators<Tools::Version>("Version");
if(options.count("version"))
{
QTextStream stream(stdout);
stream << "Actiona Executer version " << Global::ACTIONA_VERSION.toString() << ", script version " << Global::SCRIPT_VERSION.toString() << "\n";
stream.flush();
return 0;
}
if(options.count("help") || options.showUnrecognizedWarning() || options.positional().count() < 1 || (options.count("code") && options.count("script")))
{
QTextStream stream(stdout);
stream << QObject::tr("usage: ") << QCoreApplication::arguments().at(0) << " " << QObject::tr("[parameters]") << " " << QObject::tr("filename") << "\n";
stream << QObject::tr("Parameters are:") << "\n";
stream << options.getUsage();
stream.flush();
return -1;
}
app.addLibraryPath(QApplication::applicationDirPath() + "/actions");
app.addLibraryPath(QApplication::applicationDirPath() + "/plugins");
if(!options.count("nocodeqt"))
app.addLibraryPath(QApplication::applicationDirPath() + "/code");
#ifdef Q_OS_LINUX
{
#ifdef ACT_PROFILE
Tools::HighResolutionTimer timer("Load key codes");
#endif
ActionTools::KeySymHelper::loadKeyCodes();
}
#endif
// Proxy settings
int proxyMode = ActionTools::Settings::PROXY_SYSTEM;
if(options.value("proxy-mode").toString() == "none")
proxyMode = ActionTools::Settings::PROXY_NONE;
else if(options.value("proxy-mode").toString() == "custom")
proxyMode = ActionTools::Settings::PROXY_CUSTOM;
else if(options.value("proxy-mode").toString() == "system")
proxyMode = ActionTools::Settings::PROXY_SYSTEM;
else if(!options.value("proxy-mode").toString().isEmpty())
{
QTextStream stream(stdout);
stream << QObject::tr("Unknown proxy mode, values are \"none\", \"system\" (default) or \"custom\"") << "\n";
stream.flush();
return -1;
}
QNetworkProxy proxy;
switch(proxyMode)
{
case ActionTools::Settings::PROXY_NONE:
proxy.setType(QNetworkProxy::NoProxy);
break;
case ActionTools::Settings::PROXY_SYSTEM:
{
QUrl url(Global::CONNECTIVITY_URL);
QNetworkProxyQuery networkProxyQuery(url);
QList<QNetworkProxy> listOfProxies = QNetworkProxyFactory::systemProxyForQuery(networkProxyQuery);
if(!listOfProxies.isEmpty())
proxy = listOfProxies.first();
else
proxy.setType(QNetworkProxy::NoProxy);
}
break;
case ActionTools::Settings::PROXY_CUSTOM:
{
int type = ActionTools::Settings::PROXY_TYPE_SOCKS5;
if(options.value("proxy-type").toString() == "http")
type = ActionTools::Settings::PROXY_TYPE_HTTP;
else if(options.value("proxy-type").toString() == "socks")
type = ActionTools::Settings::PROXY_TYPE_SOCKS5;
else if(!options.value("proxy-type").toString().isEmpty())
{
QTextStream stream(stdout);
stream << QObject::tr("Unknown proxy type, values are \"http\" or \"socks\" (default)") << "\n";
stream.flush();
return -1;
}
QNetworkProxy proxy;
if(type == ActionTools::Settings::PROXY_TYPE_HTTP)
proxy.setType(QNetworkProxy::HttpProxy);
else
proxy.setType(QNetworkProxy::Socks5Proxy);
proxy.setHostName(options.value("proxy-host").toString());
proxy.setPort(options.value("proxy-port").toInt());
proxy.setUser(options.value("proxy-user").toString());
proxy.setPassword(options.value("proxy-password").toString());
}
break;
}
QNetworkProxy::setApplicationProxy(proxy);
QUrl protocolUrl = QUrl::fromEncoded(arguments.at(1).toUtf8());
if(protocolUrl.isValid() && protocolUrl.scheme() != "actiona")
protocolUrl = QUrl();
MainClass::ExecutionMode executionMode = MainClass::Unknown;
MainClass mainClass;
if(protocolUrl.isValid())
{
QString mode;
using QStringPair = QPair<QString, QString>;
#if (QT_VERSION >= QT_VERSION_CHECK(5, 0, 0))
for(const QStringPair &queryItem: QUrlQuery(protocolUrl.query()).queryItems())
#else
for(const QStringPair &queryItem: protocolUrl.queryItems())
#endif
{
if(queryItem.first == "mode")
{
mode = queryItem.second;
break;
}
}
if(mode == "code")
executionMode = MainClass::Code;
else if(mode == "script")
executionMode = MainClass::Script;
else
{
if(protocolUrl.path().endsWith(".ascr"))
executionMode = MainClass::Script;
else if(protocolUrl.path().endsWith(".acod"))
executionMode = MainClass::Code;
else
{
QTextStream stream(stdout);
stream << QObject::tr("Unknown execution mode, please specify mode=script or mode=code") << "\n";
stream.flush();
return -1;
}
}
if(!mainClass.start(executionMode, protocolUrl))
return -1;
}
else
{
QString filename = options.positional().at(0);
if(options.count("code"))
executionMode = MainClass::Code;
else if(options.count("script"))
executionMode = MainClass::Script;
else
{
if(filename.endsWith(".ascr"))
executionMode = MainClass::Script;
else if(filename.endsWith(".acod"))
executionMode = MainClass::Code;
else
{
QTextStream stream(stdout);
stream << QObject::tr("Unknown execution mode, please specify -s (script) or -c (code)") << "\n";
stream.flush();
return -1;
}
}
QFile file(filename);
if(!file.open(QIODevice::ReadOnly))
{
QTextStream stream(stdout);
stream << QObject::tr("Unable to read input file") << "\n";
stream.flush();
return -1;
}
if(!mainClass.start(executionMode, &file, file.fileName()))
{
file.close();
return -1;
}
}
return app.exec();
}