int main(int argc, char *argv[])
{
QApplication app(argc, argv);
app.setApplicationName("objects");
app.setApplicationVersion("0.1");
QCommandLineParser parser;
parser.setApplicationDescription("OpenGL objects");
parser.addHelpOption();
parser.addVersionOption();
QCommandLineOption objectOption(QStringList() << "o" << "object",
QCoreApplication::translate("main", "Use object <object>."),
QCoreApplication::translate("main", "object"),
QString::fromLatin1("earth.obj"));
parser.addOption(objectOption);
QCommandLineOption shaderOption(QStringList() << "s" << "shader",
QCoreApplication::translate("main", "Use shaders <shader>.[fv].glsl."),
QCoreApplication::translate("main", "shader"),
QString::fromLatin1("simple"));
parser.addOption(shaderOption);
parser.process(app);
#ifndef QT_NO_OPENGL
MainWidget widget;
widget.setObject(parser.value(objectOption));
widget.setShader(parser.value(shaderOption));
widget.show();
#else
QLabel note("OpenGL Support required");
note.show();
#endif
return app.exec();
}
bool commandLineArgumentsValid(QStringList *positionalArgs,
QStringList *ignoreMasks)
{
bool result = true;
QCommandLineParser parser;
parser.setApplicationDescription("Creates patches");
parser.addHelpOption();
parser.addVersionOption();
parser.addPositionalArgument("old", QCoreApplication::translate("main", "Path to a directory containing old version of files"));
parser.addPositionalArgument("new", QCoreApplication::translate("main", "Path to a directory containing new version of files"));
parser.addPositionalArgument("result", QCoreApplication::translate("main", "Path to a directory where resulting patch will be stored"));
QCommandLineOption ignoreOption(QStringList() << "i" << "ignore",
QCoreApplication::translate("main", "Specifies which file or folder to ignore during comparison. Can be used multiple times. e.g. -i .svn -i *.txt"),
QCoreApplication::translate("main", "mask"));
parser.addOption(ignoreOption);
// Process the actual command line arguments given by the user
parser.process(*qApp);
*positionalArgs = parser.positionalArguments();
if (positionalArgs->size() < 3)
{
fputs(qPrintable(parser.helpText()), stderr);
result = false;
}
*ignoreMasks = parser.values(ignoreOption);
return result;
}
int main(int argc, char **argv)
{
QApplication app(argc, argv);
KAboutData aboutData(QStringLiteral("test"),
i18n("Test Application"),
QStringLiteral("1.0"));
QCommandLineParser parser;
KAboutData::setApplicationData(aboutData);
parser.addVersionOption();
parser.addHelpOption();
parser.addOption(QCommandLineOption(QStringList() << QStringLiteral("path"), i18n("IMAP destination path"), QStringLiteral("argument")));
parser.addOption(QCommandLineOption(QStringList() << QStringLiteral("mimetype"), i18n("Source mimetype"), QStringLiteral("argument"), QStringLiteral("application/octet-stream")));
parser.addOption(QCommandLineOption(QStringList() << QStringLiteral("file"), i18n("Source file"), QStringLiteral("argument")));
parser.addOption(QCommandLineOption(QStringList() << QStringLiteral("count"), i18n("Number of times this file is added"), QStringLiteral("argument"), QStringLiteral("1")));
//PORTING SCRIPT: adapt aboutdata variable if necessary
aboutData.setupCommandLine(&parser);
parser.process(app);
aboutData.processCommandLine(&parser);
QString path = parser.value(QStringLiteral("path"));
QString mimetype = parser.value(QStringLiteral("mimetype"));
QString file = parser.value(QStringLiteral("file"));
int count = qMax(1, parser.value(QStringLiteral("count")).toInt());
ItemDumper d(path, file, mimetype, count);
return app.exec();
}
int main(int argc, char *argv[])
{
QApplication app(argc, argv);
KAboutData aboutData("kdeconnect.app", i18n("Awesome App"), "1.0", i18n("KDE Connect App"), KAboutLicense::GPL, i18n("(c) 2015, Aleix Pol Gonzalez"));
aboutData.addAuthor(i18n("Aleix Pol Gonzalez"), i18n("Maintainer"), "*****@*****.**");
KAboutData::setApplicationData(aboutData);
{
QCommandLineParser parser;
aboutData.setupCommandLine(&parser);
parser.addVersionOption();
parser.addHelpOption();
parser.process(app);
aboutData.processCommandLine(&parser);
}
QQmlApplicationEngine engine;
KDeclarative::KDeclarative kdeclarative;
kdeclarative.setDeclarativeEngine(&engine);
kdeclarative.setupBindings();
engine.load(QUrl("qrc:/qml/main.qml"));
return app.exec();
}
int main(int argc, char **argv)
{
QCoreApplication app(argc, argv);
const QString description = QStringLiteral("Converts desktop files to json");
const char version[] = "1.0";
app.setApplicationVersion(version);
const static QString _i = QStringLiteral("input");
const static QString _o = QStringLiteral("output");
const static QString _n = QStringLiteral("name");
QCommandLineOption input = QCommandLineOption(QStringList() << QStringLiteral("i") << _i,
QStringLiteral("Read input from file"), _n);
QCommandLineOption output = QCommandLineOption(QStringList() << QStringLiteral("o") << _o,
QStringLiteral("Write output to file"), _n);
QCommandLineParser parser;
parser.addVersionOption();
parser.addHelpOption(description);
parser.addOption(input);
parser.addOption(output);
KConfigToJson dtj(&parser, input, output);
parser.process(app);
return dtj.runMain();
}
int main(int argc, char **argv)
{
QApplication app(argc, argv);
KAboutData about = newBrainDumpAboutData();
KAboutData::setApplicationData(about);
QCommandLineParser parser;
parser.addVersionOption();
parser.addHelpOption();
parser.process(app);
about.setupCommandLine(&parser);
about.processCommandLine(&parser);
KIconLoader::global()->addAppDir("calligra");
KoGlobal::initialize();
RootSection* doc = new RootSection;
MainWindow* window = new MainWindow(doc);
window->setVisible(true);
app.exec();
// Ensure the root section is saved
doc->sectionsIO()->save();
delete doc;
app.exit(0);
}
int main(int argc, char *argv[])
{
Q_INIT_RESOURCE(mdi);
QApplication app(argc, argv);
QCoreApplication::setApplicationName("lua_debug_ui");
QCoreApplication::setOrganizationName("huangzhe");
QCoreApplication::setApplicationVersion(QT_VERSION_STR);
QCommandLineParser parser;
parser.setApplicationDescription("lua_debug_ui");
parser.addHelpOption();
parser.addVersionOption();
parser.addPositionalArgument("file", "The file to open.");
parser.process(app);
MainWindow mainWin;
if(false == mainWin.checkAndOpenFile( parser.positionalArguments().at(0), parser.positionalArguments().length() > 0))
{
return 0;
}
mainWin.show();
foreach (const QString &fileName, parser.positionalArguments())
mainWin.openFile(fileName);
return app.exec();
}
void ApplicationSettings::parse()
{
QCommandLineParser parser;
parser.setApplicationDescription(QObject::tr("i-score - An interactive sequencer for the intermedia arts."));
parser.addHelpOption();
parser.addVersionOption();
parser.addPositionalArgument("file", QCoreApplication::translate("main", "Scenario to load."));
QCommandLineOption noGUI("no-gui", QCoreApplication::translate("main", "Disable GUI"));
parser.addOption(noGUI);
QCommandLineOption noRestore("no-restore", QCoreApplication::translate("main", "Disable auto-restore"));
parser.addOption(noRestore);
QCommandLineOption autoplayOpt("autoplay", QCoreApplication::translate("main", "Auto-play the loaded scenario"));
parser.addOption(autoplayOpt);
parser.process(*qApp);
const QStringList args = parser.positionalArguments();
tryToRestore = !parser.isSet(noRestore);
gui = !parser.isSet(noGUI);
autoplay = parser.isSet(autoplayOpt) && args.size() == 1;
if(!args.empty() && QFile::exists(args[0]))
{
loadList.push_back(args[0]);
}
}
int main(int argc, char **argv)
{
QApplication app(argc, argv);
KLocalizedString::setApplicationDomain("fatcrm");
KAboutData aboutData(QStringLiteral("fatcrm"), i18n("FatCRM"),
version, i18n(description),
KAboutLicense::GPL_V2, i18n("(C) 2010-2018 KDAB"),
QString(), QStringLiteral("*****@*****.**"));
QCommandLineParser parser;
KAboutData::setApplicationData(aboutData);
parser.addVersionOption();
parser.addHelpOption();
QCommandLineOption noOverlayOption("nooverlay", i18n("Do not display the overlay during initial data loading"));
parser.addOption(noOverlayOption);
aboutData.setupCommandLine(&parser);
parser.process(app);
aboutData.processCommandLine(&parser);
QMimeDatabase db;
if (!db.mimeTypeForName("application/x-vnd.kdab.crm.opportunity").isValid()) {
KMessageBox::error(nullptr, i18n("Mimetype application/x-vnd.kdab.crm.opportunity not found, please check your FatCRM installation"));
return 1;
}
KDBusService service(KDBusService::Multiple);
auto *window = new MainWindow(!parser.isSet(noOverlayOption));
window->setAttribute(Qt::WA_DeleteOnClose);
window->show();
return app.exec();
}
int main(int argc, char *argv[])
{
QCoreApplication app(argc, argv);
QCoreApplication::setApplicationName("MyFib");
QCoreApplication::setApplicationVersion("1.1");
QCommandLineParser clap;
clap.setApplicationDescription("Calculates fibonacci numbers, slowly!");
clap.addHelpOption();
clap.addVersionOption();
const int def_n = 42;
QCommandLineOption numopt(QStringList() << "n", "number", "Number", "N");
numopt.setDefaultValue(QString::number(def_n, 10));
clap.addOption(numopt);
clap.process(app);
bool n_ok = true;
int n = clap.value(numopt).toInt(&n_ok);
MyFibCalc* calc = new MyFibCalc(&app, n_ok?n:def_n);
QObject::connect(calc, SIGNAL(done()), &app, SLOT(quit()));
QTimer::singleShot(0, calc, SLOT(calculate()));
return app.exec();
}
int main(int argc, char **argv)
{
PrintQueue app(argc, argv);
app.setOrganizationDomain("org.kde");
KAboutData about("PrintQueue",
i18n("Print Queue"),
PM_VERSION,
i18n("Print Queue"),
KAboutLicense::GPL,
i18n("(C) 2010-2013 Daniel Nicoletti"));
about.addAuthor(QStringLiteral("Daniel Nicoletti"), QString(), "*****@*****.**");
about.addAuthor(QStringLiteral("Lukáš Tinkl"), i18n("Port to Qt 5 / Plasma 5"), QStringLiteral("*****@*****.**"));
KAboutData::setApplicationData(about);
KDBusService service(KDBusService::Unique);
QCommandLineParser parser;
about.setupCommandLine(&parser);
parser.addVersionOption();
parser.addHelpOption();
parser.addPositionalArgument("queue", i18n("Show printer queue(s)"));
parser.process(app);
about.processCommandLine(&parser);
QObject::connect(&service, &KDBusService::activateRequested, &app, &PrintQueue::showQueues);
app.showQueues(parser.positionalArguments());
return app.exec();
}
int main(int argc, char *argv[])
{
QApplication app(argc, argv);
QApplication::setApplicationName("Editor");
QApplication::setApplicationVersion("1.0");
#if C3_OS == C3_OS_WINDOWS_NT
//Windows native theme looks so ugly
app.setStyle("fusion");
#endif
QCommandLineParser parser;
parser.setApplicationDescription("The Editor");
parser.addHelpOption();
parser.addVersionOption();
QCommandLineOption dataDirOption("root",
"Root directory location.\nThis will override ENGINE_ROOT.",
"path");
parser.addOption(dataDirOption);
parser.process(app);
QProcessEnvironment env = QProcessEnvironment::systemEnvironment();
QString absPath;
if(!parser.value(dataDirOption).isEmpty())
{
absPath = parser.value(dataDirOption);
}
else if(env.contains("ENGINE_ROOT"))
absPath = env.value("ENGINE_ROOT");
else
absPath = ".";
QFileInfo dirInfo(absPath);
if(!dirInfo.exists() || !dirInfo.isDir() || !QFileInfo::exists(absPath + "/Data"))
{
const char* msg = "Invalid root directory!";
QMessageBox::critical(nullptr, app.applicationName(), msg);
throw msg;
}
absPath = dirInfo.canonicalFilePath();
EngineLoader.SetRootDirectory(absPath.toUtf8().constData());
c3::RC.Loader = &EngineLoader;
c3::RC.Loader->InitEngine();
c3::FEditor EditorController;
c3::RC.Editor = &EditorController;
QSurfaceFormat format;
format.setVersion(4, 5);
format.setProfile(QSurfaceFormat::CoreProfile);
format.setDepthBufferSize(24);
format.setStencilBufferSize(8);
QSurfaceFormat::setDefaultFormat(format);
MainWindow mainWindow;
c3::FLogDisplay* LogDisplay = static_cast<c3::FLogDisplay*>(EditorController.GetLogDisplay());
QObject::connect(LogDisplay, &c3::FLogDisplay::LogRefreshed,
&mainWindow, &MainWindow::OnLogChanged);
mainWindow.showMaximized();
app.exec();
}
int main(int argc, char *argv[])
{
QApplication a(argc, argv);
QApplication::setApplicationName("JAERO");
QApplication::setApplicationVersion("1.0.4.4");
QCommandLineParser cmdparser;
cmdparser.setApplicationDescription("Demodulatoe and decode Satcom ACARS");
cmdparser.addHelpOption();
cmdparser.addVersionOption();
QCommandLineOption settingsnameoption(QStringList() << "s" << "settings-name",QApplication::translate("main", "Run with setting name <name>."),QApplication::translate("main", "name"));
settingsnameoption.setDefaultValue("");
cmdparser.addOption(settingsnameoption);
cmdparser.process(a);
settings_name=cmdparser.value(settingsnameoption);
if(settings_name.isEmpty())settings_name="JAERO";
else settings_name="JAERO-"+settings_name;
MainWindow w;
w.show();
return a.exec();
}
int main(int argc, char **argv)
{
QGuiApplication app(argc, argv);
QCoreApplication::setApplicationName("Qt Render Control Example");
QCoreApplication::setOrganizationName("QtProject");
QCoreApplication::setApplicationVersion(QT_VERSION_STR);
QCommandLineParser parser;
parser.setApplicationDescription(QCoreApplication::applicationName());
parser.addHelpOption();
parser.addVersionOption();
QCommandLineOption threadedOption("threaded", "Threaded Rendering");
parser.addOption(threadedOption);
parser.process(app);
QScopedPointer<QWindow> window;
if (parser.isSet(threadedOption)) {
qWarning("Using separate Qt Quick render thread");
window.reset(new WindowMultiThreaded);
} else {
qWarning("Using single-threaded rendering");
window.reset(new WindowSingleThreaded);
}
window->resize(1024, 768);
window->show();
return app.exec();
}
int main(int argc, char **argv)
{
qDebug() << "Test kinvocation by desktop name.";
KAboutData aboutData(QStringLiteral("testKInvocation"), i18n("Test for KMail invocation"), QStringLiteral("0.0"));
QCoreApplication app(argc, argv);
QCommandLineParser parser;
KAboutData::setApplicationData(aboutData);
parser.addVersionOption();
parser.addHelpOption();
aboutData.setupCommandLine(&parser);
parser.process(app);
aboutData.processCommandLine(&parser);
QString errmsg;
if (KToolInvocation::startServiceByDesktopName(QStringLiteral("org.kde.kmail"), QString(), &errmsg)) {
qDebug() << " Can not start kmail" << errmsg;
}
const QString desktopFile = QStandardPaths::locate(QStandardPaths::ApplicationsLocation, QStringLiteral("org.kde.korganizer.desktop"));
if (KToolInvocation::startServiceByDesktopPath(desktopFile) > 0) {
qDebug() << " Can not start korganizer";
}
qDebug() << "kinvocation done.";
return 0;
}
int main(int argc, char *argv[])
{
QApplication app(argc, argv);
#if 0
#if QT_VERSION >= QT_VERSION_CHECK(5, 0, 0)
qInstallMessageHandler(myMessageHandler);
#else
qInstallMsgHandler(myMessageHandler);
#endif
#endif
//qDebug("hello");
//qDebug() << "world";
QCoreApplication::setApplicationVersion(QT_VERSION_STR);
QCommandLineParser parser;
parser.addHelpOption();
parser.addVersionOption();
parser.process(app);
MainWindow mainWindow;
const QRect availableGeometry = QApplication::desktop()->availableGeometry(&mainWindow);
mainWindow.resize(availableGeometry.width() / 3, availableGeometry.height() / 2);
//mainWindow.show();
mainWindow.showMaximized();
QFile file("qss/stylesheet.qss");
if (!file.open(QFile::ReadOnly)) {
QMessageBox::warning(NULL, "Codecs",
QString("Cannot read file %1").arg(file.errorString()));
}
app.setStyleSheet(file.readAll());
file.close();
return app.exec();
}
int main(int argc, char* argv[])
{
QApplication app(argc, argv);
QCommandLineParser parser;
parser.addVersionOption();
parser.addHelpOption();
parser.addOption(QCommandLineOption(QStringList() << QLatin1String("demopoints_single"), i18n("Add built-in demo points as single markers")));
parser.addOption(QCommandLineOption(QStringList() << QLatin1String("demopoints_group"), i18n("Add built-in demo points as groupable markers")));
parser.addOption(QCommandLineOption(QStringList() << QLatin1String("single"), i18n("Do not group the displayed images")));
parser.addPositionalArgument(QString::fromLatin1("images"), i18n("List of images"), QString::fromLatin1("[images...]"));
parser.process(app);
// get the list of images to load on startup:
QList<QUrl> imagesList;
foreach(const QString& file, parser.positionalArguments())
{
const QUrl argUrl = QUrl::fromLocalFile(file);
qDebug() << argUrl;
imagesList << argUrl;
}
MainWindow* const myMainWindow = new MainWindow(&parser);
myMainWindow->show();
myMainWindow->slotScheduleImagesForLoading(imagesList);
return app.exec();
}
int main(int argc, char **argv)
{
QApplication app(argc, argv);
KLocalizedString::setApplicationDomain("polka");
KAboutData about( QStringLiteral("polka"), i18n("Polka"), version,
i18n("The humane address book for the cloud"), KAboutLicense::GPL,
i18n("(c) 2009-2015 Cornelius Schumacher"), QStringLiteral(),
QStringLiteral("http://cornelius-schumacher.de/polka/"),
QStringLiteral("*****@*****.**"));
about.addAuthor(i18n("Cornelius Schumacher"), i18n("Creator"),
QStringLiteral("*****@*****.**"));
KAboutData::setApplicationData(about);
QCommandLineParser parser;
parser.addHelpOption();
parser.addVersionOption();
about.setupCommandLine(&parser);
parser.process(app);
about.processCommandLine(&parser);
MainWindow *widget = new MainWindow;
widget->show();
return app.exec();
}
int main(int argc, char **argv)
{
QCoreApplication app(argc, argv);
QCommandLineParser parser;
QCoreApplication::setApplicationName("IDFS master node");
QCoreApplication::setApplicationVersion("1.0");
parser.setApplicationDescription("Where all file metadata is stored.");
parser.addHelpOption();
parser.addVersionOption();
QCommandLineOption portOption(QStringList() << "p" << "port",
"Host's port (default is 8001).", "port", "8001");
parser.addOption(portOption);
parser.process(app);
bool ok;
quint16 port = parser.value(portOption).toUInt(&ok);
if (!ok)
{
qDebug() << "Could not parse the port value, using 8001";
port = 8001;
}
MasterNode master;
master.listen(QHostAddress::AnyIPv4, port);
app.exec();
return 1;
}
int main(int argc, char *argv[])
{
QCoreApplication app(argc, argv);
// some command line arguments parsing stuff
QCoreApplication::setApplicationName("ujea");
QCoreApplication::setApplicationVersion("1.2");
QString hostname = QHostInfo::localHostName();
QCommandLineParser parser;
parser.setApplicationDescription("Universal job execution agent using AMQP queue");
parser.addHelpOption();
parser.addVersionOption();
parser.addOption(QCommandLineOption("aliveInterval", "Interval in ms between alive messages (1000).", "aliveInterval", "1000"));
parser.addOption(QCommandLineOption("aliveTTL", "TTL in queue for alive messages (1500).", "aliveTTL", "1500"));
parser.addOption(QCommandLineOption("queueCmd", "Commands queue name ("+hostname+"_cmd).", "queueCmd", hostname+"_cmd"));
parser.addOption(QCommandLineOption("queueRpl", "Replays queue name ("+hostname+"_rpl).", "queueRpl", hostname+"_rpl"));
parser.addOption(QCommandLineOption("execRegex", "Regex for permited commands. (none)", "execRegex", ""));
parser.addPositionalArgument("url", QCoreApplication::translate("main", "AMQP url"));
parser.process(app);
const QStringList args = parser.positionalArguments();
// we need to have 1 argument and optional named arguments
if (args.count() != 1) parser.showHelp(-1);
// create and execure worker
JobsExecuter qw{QUrl(args.value(0)), parser.value("queueCmd"), parser.value("queueRpl"),
parser.value("aliveInterval").toInt(), parser.value("aliveTTL").toInt(),
parser.value("execRegex")};
return app.exec();
}
int main(int argc, char *argv[]) {
QApplication app(argc, argv);
qApp->setAttribute(Qt::AA_UseHighDpiPixmaps);
QCoreApplication::setApplicationName("Focus");
QCoreApplication::setOrganizationName("C-CINA");
QCoreApplication::setOrganizationDomain("c-cina.org");
QCommandLineParser parser;
parser.setApplicationDescription("Focus Software Suite: Main Graphical User Interface & Project Manager");
parser.addHelpOption();
parser.addVersionOption();
parser.addPositionalArgument("project_dir", "Path of the focus Project to be opened.");
parser.process(app);
UserPreferences().loadAllFontSettings();
if (!parser.positionalArguments().isEmpty()) {
loadMainWindow(parser.positionalArguments().first());
} else {
if(!openProject()) {
QApplication::quit();
return 0;
}
}
return app.exec();
}
LxQtPanelApplication::LxQtPanelApplication(int& argc, char** argv)
: LxQt::Application(argc, argv, true)
{
QCoreApplication::setApplicationName(QStringLiteral("lxqt-panel"));
QCoreApplication::setApplicationVersion(LXQT_VERSION);
QCommandLineParser parser;
parser.setApplicationDescription(QStringLiteral("LXQt panel"));
parser.addHelpOption();
parser.addVersionOption();
QCommandLineOption configFileOption(QStringList()
<< QStringLiteral("c") << QStringLiteral("config") << QStringLiteral("configfile"),
QCoreApplication::translate("main", "Use alternate configuration file."),
QCoreApplication::translate("main", "Configuration file"));
parser.addOption(configFileOption);
parser.process(*this);
const QString configFile = parser.value(configFileOption);
if (configFile.isEmpty())
mSettings = new LxQt::Settings(QStringLiteral("panel"), this);
else
mSettings = new LxQt::Settings(configFile, QSettings::IniFormat, this);
// This is a workaround for Qt 5 bug #40681.
Q_FOREACH(QScreen* screen, screens())
{
connect(screen, &QScreen::destroyed, this, &LxQtPanelApplication::screenDestroyed);
}
void parseCommandLine(QCoreApplication &app, CmdLineOptions *opts)
{
QCommandLineParser parser;
parser.setApplicationDescription("remove db key at specified path");
parser.addHelpOption();
parser.addVersionOption();
parser.addPositionalArgument("key", QCoreApplication::translate("main", "key"));
QCommandLineOption debugOption(QStringList() << "d" << "debug",
QCoreApplication::translate("main", "enable debug/verbose logging"));
parser.addOption(debugOption);
parser.process(app);
opts->debuggingEnabled = parser.isSet(debugOption);
const QStringList posArgs = parser.positionalArguments();
if (posArgs.size() < 1)
{
qCritical("invalid arguments");
exit(1);
}
opts->key = posArgs.at(0);
DbdLogging::logger()->debugMode = opts->debuggingEnabled;
qDebug() << "debugging enabled:" << opts->debuggingEnabled;
qDebug() << "key:" << opts->key;
}
int main(int argc, char **argv) {
QApplication app(argc, argv);
QApplication::setApplicationName("ViewDown");
QApplication::setApplicationVersion("1.0");
app.setWindowIcon(QIcon("qrc:///viewdown.ico"));
QCommandLineParser parser;
parser.setApplicationDescription("Markdown viewer, reloading on changes.");
parser.addPositionalArgument("file", "markdown file to view and reload on change.");
parser.addPositionalArgument("watch", "files or directories to watch as trigger for reload.", "[watch...]");
const QCommandLineOption styleOption("s", "css file to use as stylesheet.", "css");
parser.addOption(styleOption);
parser.addHelpOption();
parser.addVersionOption();
parser.process(app);
QUrl styleUrl;
if (parser.isSet(styleOption)) {
const QString path = parser.value(styleOption);
QFileInfo info = QFileInfo(path);
if (info.exists())
styleUrl = QUrl::fromLocalFile(info.canonicalFilePath());
else
qWarning("No such file: %s", qPrintable(path));
}
if (styleUrl.isEmpty())
styleUrl = QUrl("qrc:///github.css");
MainWindow *browser = new MainWindow(parser.positionalArguments(), styleUrl);
browser->show();
return app.exec();
}
int main(int argc, char **argv)
{
LXQt::SingleApplication app(argc, argv);
app.setOrganizationName(QStringLiteral("lxqt"));
app.setApplicationName(QStringLiteral("lxqt-config"));
app.setAttribute(Qt::AA_UseHighDpiPixmaps, true);
QCommandLineParser parser;
parser.setApplicationDescription(QStringLiteral("LXQt Config"));
const QString VERINFO = QStringLiteral(LXQT_CONFIG_VERSION
"\nliblxqt " LXQT_VERSION
"\nQt " QT_VERSION_STR);
app.setApplicationVersion(VERINFO);
parser.addVersionOption();
parser.addHelpOption();
parser.process(app);
// ensure that we use lxqt-config.menu file.
qputenv("XDG_MENU_PREFIX", "lxqt-");
LXQtConfig::MainWindow w;
app.setActivationWindow(&w);
QSize s = QSettings{}.value("size").toSize();
if (!s.isEmpty())
w.resize(s);
w.show();
int ret = app.exec();
QSettings{}.setValue("size", w.size());
return ret;
}
int main(int argc, char **argv)
{
QApplication app(argc, argv);
app.setAttribute(Qt::AA_UseHighDpiPixmaps, true);
app.setAttribute(Qt::AA_EnableHighDpiScaling);
KLocalizedString::setApplicationDomain("contactprintthemeeditor");
KAboutData aboutData(QStringLiteral("contactprintthemeeditor"),
i18n("Contact Print Theme Editor"),
QStringLiteral(GRANTLEEEDITOR_VERSION),
i18n("Contact Print Theme Editor"),
KAboutLicense::GPL_V2,
i18n("Copyright © 2015-2016 contactprintthemeeditor authors"));
aboutData.addAuthor(i18n("Laurent Montel"), i18n("Maintainer"), QStringLiteral("*****@*****.**"));
QApplication::setWindowIcon(QIcon::fromTheme(QStringLiteral("kaddressbook")));
aboutData.setOrganizationDomain(QByteArray("kde.org"));
aboutData.setProductName(QByteArray("contactprintthemeeditor"));
KAboutData::setApplicationData(aboutData);
KCrash::initialize();
QCommandLineParser parser;
parser.addVersionOption();
parser.addHelpOption();
aboutData.setupCommandLine(&parser);
parser.process(app);
aboutData.processCommandLine(&parser);
KDBusService service;
ThemeEditorMainWindow *mw = new ThemeEditorMainWindow;
mw->show();
const int ret = app.exec();
return ret;
}
int main(int argc, char *argv[])
{
LXQt::Application a(argc, argv);
a.setAttribute(Qt::AA_UseHighDpiPixmaps, true);
QCommandLineParser parser;
parser.setApplicationDescription(QStringLiteral("LXQt OpenSSH Askpass"));
const QString VERINFO = QStringLiteral(LXQT_ASKPASS_VERSION
"\nliblxqt " LXQT_VERSION
"\nQt " QT_VERSION_STR);
a.setApplicationVersion(VERINFO);
parser.addVersionOption();
parser.addHelpOption();
parser.process(a);
// TODO/FIXME: maybe a better algorithm?
QString prompt;
if (a.arguments().count() < 2)
prompt = QObject::tr("unknown request");
else
prompt = a.arguments().at(a.arguments().count()-1);
MainWindow w(prompt);
w.show();
return a.exec();
}
int main(int argc, char *argv[])
{
QApplication a(argc, argv);
a.setApplicationName(TARGET);
a.setApplicationVersion("1");
#ifdef __linux__
a.setWindowIcon(QIcon(":MoleGraph.png"));
#endif
QCommandLineParser parser;
parser.setApplicationDescription("Test helper");
parser.addHelpOption();
parser.addVersionOption();
QCommandLineOption openOption(QStringList() << "o" << "open-file",
QCoreApplication::translate("main", "Open file."), QCoreApplication::translate("main", "directory"));
parser.addOption(openOption);
QCommandLineOption withoutValuesOption(QStringList() << "w" << "without-values",
QCoreApplication::translate("main", "Modifier for opening file without values (just measurement template)."));
parser.addOption(withoutValuesOption);
parser.addPositionalArgument("file", "file to open");
parser.process(a);
QString fileName = parser.value(openOption);
const QStringList arguments = parser.positionalArguments();
if (arguments.size() > 0)
fileName = arguments[0];
MainWindow w(a, fileName, parser.isSet(withoutValuesOption));
w.show();
return a.exec();
}
int main(int argc, char **argv)
{
QApplication app(argc, argv);
app.setWindowIcon(QIcon::fromTheme("applications-other"));
KLocalizedString::setApplicationDomain("qapt-gst-helper");
KAboutData aboutData("qapt-gst-helper",
i18nc("@title", "QApt Codec Searcher"),
version,
i18nc("@info", description),
KAboutLicense::LicenseKey::GPL,
i18nc("@info:credit", "(C) 2011 Jonathan Thomas"));
aboutData.addAuthor(i18nc("@info:credit", "Jonathan Thomas"),
QString(),
QStringLiteral("*****@*****.**"));
aboutData.addAuthor(i18nc("@info:credit", "Harald Sitter"),
i18nc("@info:credit", "Qt 5 port"),
QStringLiteral("*****@*****.**"));
KAboutData::setApplicationData(aboutData);
QCommandLineParser parser;
parser.addHelpOption();
parser.addVersionOption();
QCommandLineOption transientOption(QStringLiteral("transient-for"),
i18nc("@info:shell", "Attaches the window to an X app specified by winid"),
i18nc("@info:shell value name", "winid"),
QStringLiteral("0"));
parser.addOption(transientOption);
parser.addPositionalArgument("GStreamer Info",
i18nc("@info:shell", "GStreamer install info"));
aboutData.setupCommandLine(&parser);
parser.process(app);
aboutData.processCommandLine(&parser);
GError *error = nullptr;
gst_init_check(&argc, &argv, &error);
if (error) {
// TODO: we should probably show an error message. API documention suggests
// so at least. Then again explaining random init errors to the user
// might be a bit tricky.
#warning FIXME 3.1 show error msgbox when gstreamer init fails
return GST_INSTALL_PLUGINS_ERROR;
}
// do not restore!
if (app.isSessionRestored()) {
exit(0);
}
int winId = parser.value(transientOption).toInt();
QStringList details = parser.positionalArguments();
PluginHelper pluginHelper(0, details, winId);
pluginHelper.run();
return app.exec();
}
int main(int argc, char *argv[])
{
QApplication app(argc, argv);
KLocalizedString::setApplicationDomain("ktp-log-viewer");
KAboutData aboutData("ktp-log-viewer",
i18n("KDE IM Log Viewer"),
QStringLiteral(KTP_TEXT_UI_VERSION_STRING));
aboutData.addAuthor(i18n("David Edmundson"), i18n("Developer"), "*****@*****.**");
aboutData.addAuthor(i18n("Daniele E. Domenichelli"), i18n("Developer"), "*****@*****.**");
aboutData.addAuthor(i18n("Dan Vrátil"), i18n("Developer"), "*****@*****.**");
aboutData.setProductName("telepathy/log-viewer"); //set the correct name for bug reporting
aboutData.setOrganizationDomain(QByteArray("kde.org"));
aboutData.setLicense(KAboutLicense::GPL_V2);
KAboutData::setApplicationData(aboutData);
// register to DBus
const KDBusService dbusService(KDBusService::Multiple);
QCommandLineParser parser;
parser.addHelpOption();
parser.addVersionOption();
QCommandLineOption accountId(QStringLiteral("accountID"), i18n("The UID of the account to preselect"));
QCommandLineOption contactId(QStringLiteral("contactID"), i18n("The UID of the contact to preselect"));
parser.addOption(accountId);
parser.addOption(contactId);
parser.process(app);
Tp::registerTypes();
Tp::AccountFactoryPtr accountFactory = Tp::AccountFactory::create(
QDBusConnection::sessionBus(),
Tp::Features() << Tp::Account::FeatureCore
<< Tp::Account::FeatureAvatar
<< Tp::Account::FeatureProfile);
Tp::ConnectionFactoryPtr connectionFactory = Tp::ConnectionFactory::create(
QDBusConnection::sessionBus(),
Tp::Features() << Tp::Connection::FeatureCore
<< Tp::Connection::FeatureSelfContact
<< Tp::Connection::FeatureRoster);
Tp::ContactFactoryPtr contactFactory = KTp::ContactFactory::create(
Tp::Features() << Tp::Contact::FeatureAlias
<< Tp::Contact::FeatureAvatarData
<< Tp::Contact::FeatureSimplePresence
<< Tp::Contact::FeatureCapabilities);
Tp::ChannelFactoryPtr channelFactory = Tp::ChannelFactory::create(QDBusConnection::sessionBus());
LogViewer *logViewer = new LogViewer(accountFactory, connectionFactory, channelFactory, contactFactory);
logViewer->show();
return app.exec();
}